Merge pull request #15 from purescript-contrib/0.9.1-updates

Updates for 0.9.1

Author: garyb

.gitignore

@@ -1,8 +1,6 @@
 /.*
 !/.gitignore
 !/.travis.yml
-bower_components/
-node_modules/
-output/
-dist/
-npm-debug.log
+/bower_components/
+/node_modules/
+/output/

.travis.yml

@@ -1,17 +1,17 @@
 language: node_js
-sudo: false
-node_js:
-  - 5
+dist: trusty
+sudo: required
+node_js: 6
 install:
   - npm install -g bower
   - npm install
 script:
-  - npm test
+  - bower install --production
+  - npm run -s build
+  - bower install
+  - npm -s test
 after_success:
 - >-
   test $TRAVIS_TAG &&
-  node_modules/.bin/psc-publish > .pursuit.json &&
-  curl -X POST http://pursuit.purescript.org/packages \
-    -d @.pursuit.json \
-    -H 'Accept: application/json' \
-    -H "Authorization: token ${GITHUB_TOKEN}"
+  echo $GITHUB_TOKEN | pulp login &&
+  echo y | pulp publish --no-push

bower.json

@@ -22,11 +22,12 @@
   },
   "license": "MIT",
   "dependencies": {
-    "purescript-argonaut-core": "^0.2.0",
-    "purescript-generics": "^0.7.0",
-    "purescript-integers": "^0.2.1"
+    "purescript-argonaut-core": "^1.0.0",
+    "purescript-generics": "^1.0.0",
+    "purescript-integers": "^1.0.0"
   },
   "devDependencies": {
-    "purescript-strongcheck-generics": "^0.3.0"
+    "purescript-strongcheck": "^1.1.1",
+    "purescript-strongcheck-generics": "garyb/purescript-strongcheck-generics#0.9.1-updates"
   }
 }

package.json

@@ -1,14 +1,14 @@
 {
   "private": true,
   "scripts": {
-    "postinstall": "pulp dep install",
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "pulp build",
+    "build": "pulp build --censor-lib --strict",
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^7.0.0",
-    "purescript": "^0.7.6",
-    "rimraf": "^2.4.4"
+    "pulp": "^9.0.0",
+    "purescript-psa": "^0.3.9",
+    "purescript": "^0.9.1",
+    "rimraf": "^2.5.0"
   }
 }

src/Data/Argonaut/Combinators.purs

@@ -1,141 +1,7 @@
 module Data.Argonaut.Decode
-  ( DecodeJson
-  , decodeJson
-  , gDecodeJson
-  , gDecodeJson'
-  , decodeMaybe
+  ( module Data.Argonaut.Decode.Class
+  , module Data.Argonaut.Decode.Combinators
   ) where
 
-import Prelude
-
-import Control.Alt ((<|>))
-import Control.Bind ((=<<))
-import Data.Argonaut.Core (Json(), isNull, foldJsonNull, foldJsonBoolean, foldJsonNumber, foldJsonString, toArray, toNumber, toObject, toString, toBoolean)
-import Data.Array (zipWithA)
-import Data.Either (either, Either(..))
-import Data.Foldable (find)
-import Data.Generic (Generic, GenericSpine(..), GenericSignature(..), fromSpine, toSignature)
-import Data.Int (fromNumber)
-import Data.List (List(..), toList)
-import Data.Map as Map
-import Data.Maybe (maybe, Maybe(..))
-import Data.String (charAt, toChar)
-import Data.StrMap as M
-import Data.Traversable (traverse, for)
-import Data.Tuple (Tuple(..))
-import Type.Proxy (Proxy(..))
-
-class DecodeJson a where
-  decodeJson :: Json -> Either String a
-
--- | Decode `Json` representation of a value which has a `Generic` type.
-gDecodeJson :: forall a. (Generic a) => Json -> Either String a
-gDecodeJson json = maybe (Left "fromSpine failed") Right <<< fromSpine
-                 =<< gDecodeJson' (toSignature (Proxy :: Proxy a)) json
-
--- | Decode `Json` representation of a `GenericSpine`.
-gDecodeJson' :: GenericSignature -> Json -> Either String GenericSpine
-gDecodeJson' signature json = case signature of
-  SigNumber -> SNumber <$> mFail "Expected a number" (toNumber json)
-  SigInt -> SInt <$> mFail "Expected an integer number" (fromNumber =<< toNumber json)
-  SigString -> SString <$> mFail "Expected a string" (toString json)
-  SigChar -> SChar <$> mFail "Expected a char" (toChar =<< toString json)
-  SigBoolean -> SBoolean <$> mFail "Expected a boolean" (toBoolean json)
-  SigArray thunk -> do
-    jArr <- mFail "Expected an array" $ toArray json
-    SArray <$> traverse (map const <<< gDecodeJson' (thunk unit)) jArr
-  SigRecord props -> do
-    jObj <- mFail "Expected an object" $ toObject json
-    SRecord <$> for props \({recLabel: lbl, recValue: val}) -> do
-      pf <- mFail ("'" <> lbl <> "' property missing") (M.lookup lbl jObj)
-      sp <- gDecodeJson' (val unit) pf
-      pure { recLabel: lbl, recValue: const sp }
-  SigProd typeConstr alts -> do
-    let decodingErr msg = "When decoding a " ++ typeConstr ++ ": " ++ msg
-    jObj <- mFail (decodingErr "expected an object") (toObject json)
-    tagJson  <- mFail (decodingErr "'tag' property is missing") (M.lookup "tag" jObj)
-    tag <- mFail (decodingErr "'tag' property is not a string") (toString tagJson)
-    case find ((tag ==) <<< _.sigConstructor) alts of
-      Nothing -> Left (decodingErr ("'" <> tag <> "' isn't a valid constructor"))
-      Just { sigValues: sigValues } -> do
-        vals <- mFail (decodingErr "'values' array is missing") (toArray =<< M.lookup "values" jObj)
-        sps  <- zipWithA (\k -> gDecodeJson' (k unit)) sigValues vals
-        pure (SProd tag (const <$> sps))
-  where
-  mFail :: forall a. String -> Maybe a -> Either String a
-  mFail msg = maybe (Left msg) Right
-
-instance decodeJsonMaybe :: (DecodeJson a) => DecodeJson (Maybe a) where
-  decodeJson j
-    | isNull j = pure Nothing
-    | otherwise = (Just <$> decodeJson j) <|> (pure Nothing)
-
-instance decodeJsonTuple :: (DecodeJson a, DecodeJson b) => DecodeJson (Tuple a b) where
-  decodeJson j = decodeJson j >>= f
-    where
-    f (Cons a (Cons b Nil)) = Tuple <$> decodeJson a <*> decodeJson b
-    f _ = Left "Couldn't decode Tuple"
-
-instance decodeJsonEither :: (DecodeJson a, DecodeJson b) => DecodeJson (Either a b) where
-  decodeJson j =
-    case toObject j of
-      Just obj -> do
-        tag <- just (M.lookup "tag" obj)
-        val <- just (M.lookup "value" obj)
-        case toString tag of
-          Just "Right" ->
-            Right <$> decodeJson val
-          Just "Left" ->
-            Left <$> decodeJson val
-          _ ->
-            Left "Couldn't decode Either"
-      _ ->
-        Left "Couldn't decode Either"
-    where
-    just (Just x) = Right x
-    just Nothing  = Left "Couldn't decode Either"
-
-instance decodeJsonNull :: DecodeJson Unit where
-  decodeJson = foldJsonNull (Left "Not null") (const $ Right unit)
-
-instance decodeJsonBoolean :: DecodeJson Boolean where
-  decodeJson = foldJsonBoolean (Left "Not a Boolean") Right
-
-instance decodeJsonNumber :: DecodeJson Number where
-  decodeJson = foldJsonNumber (Left "Not a Number") Right
-
-instance decodeJsonInt :: DecodeJson Int where
-  decodeJson num = foldJsonNumber (Left "Not a Number") go num
-    where go num = maybe (Left "Not an Int") Right $ fromNumber num
-
-instance decodeJsonString :: DecodeJson String where
-  decodeJson = foldJsonString (Left "Not a String") Right
-
-instance decodeJsonJson :: DecodeJson Json where
-  decodeJson = Right
-
-instance decodeJsonChar :: DecodeJson Char where
-  decodeJson j = (charAt 0 <$> decodeJson j) >>= go where
-    go Nothing  = Left $ "Expected character but found: " ++ show j
-    go (Just c) = Right c
-
-instance decodeStrMap :: (DecodeJson a) => DecodeJson (M.StrMap a) where
-  decodeJson json = maybe (Left "Couldn't decode StrMap") Right $ do
-    obj <- toObject json
-    traverse decodeMaybe obj
-
-instance decodeArray :: (DecodeJson a) => DecodeJson (Array a) where
-  decodeJson json = maybe (Left "Couldn't decode Array") Right $ do
-    obj <- toArray json
-    traverse decodeMaybe obj
-
-instance decodeList :: (DecodeJson a) => DecodeJson (List a) where
-  decodeJson json = maybe (Left "Couldn't decode List") Right $ do
-    lst <- toList <$> toArray json
-    traverse decodeMaybe lst
-
-instance decodeMap :: (Ord a, DecodeJson a, DecodeJson b) => DecodeJson (Map.Map a b) where
-  decodeJson j = Map.fromList <$> decodeJson j
-
-decodeMaybe :: forall a. (DecodeJson a) => Json -> Maybe a
-decodeMaybe json = either (const Nothing) pure $ decodeJson json
+import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson, gDecodeJson, gDecodeJson')
+import Data.Argonaut.Decode.Combinators (getField, (.?))