Resolving conflicts with recent updates.

Author: dgendill

.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
 dist: trusty
 sudo: required
-node_js: 6
+node_js: stable
 install:
   - npm install -g bower
   - npm install

bower.json

@@ -22,11 +22,11 @@
   },
   "license": "MIT",
   "dependencies": {
-    "purescript-argonaut-core": "^2.0.0",
-    "purescript-generics": "^3.0.0",
-    "purescript-integers": "^2.0.0"
+    "purescript-argonaut-core": "^3.0.0",
+    "purescript-generics": "^4.0.0",
+    "purescript-integers": "^3.0.0"
   },
   "devDependencies": {
-    "purescript-strongcheck": "^2.0.0"
+    "purescript-strongcheck": "^3.1.0"
   }
 }

package.json

@@ -6,9 +6,9 @@
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^10.0.0",
-    "purescript-psa": "^0.4.0",
-    "purescript": "^0.10.7",
-    "rimraf": "^2.5.4"
+    "pulp": "^11.0.0",
+    "purescript-psa": "^0.5.0",
+    "purescript": "^0.11.1",
+    "rimraf": "^2.6.1"
   }
 }

src/Data/Argonaut/Decode.purs

@@ -3,5 +3,5 @@ module Data.Argonaut.Decode
   , module Data.Argonaut.Decode.Combinators
   ) where
 
-import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson, gDecodeJson, gDecodeJson')
+import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson)
 import Data.Argonaut.Decode.Combinators (getField, (.?))

src/Data/Argonaut/Decode/Class.purs

@@ -1,80 +1,42 @@
 module Data.Argonaut.Decode.Class
   ( class DecodeJson
   , decodeJson
-  , gDecodeJson
-  , gDecodeJson'
   ) where
 
 import Prelude
 
 import Data.Array as Arr
 import Control.Alternative (class Plus)
-import Data.Argonaut.Core (Json, JArray, JObject, isNull, foldJsonNull, foldJsonBoolean, foldJsonNumber, foldJsonString, toArray, toNumber, toObject, toString, toBoolean)
-import Data.Array (zipWithA)
+import Data.Argonaut.Core (Json, JArray, JObject, isNull, foldJsonNull, foldJsonBoolean, foldJsonNumber, foldJsonString, toArray, toObject, toString)
 import Data.Bifunctor (lmap)
 import Data.Either (Either(..))
-import Data.Foldable (find)
-import Data.Generic (class Generic, GenericSpine(..), GenericSignature(..), fromSpine, toSignature)
 import Data.Int (fromNumber)
 import Data.List (List(..), (:), fromFoldable)
 import Data.Map as M
 import Data.List as L
 import Data.Maybe (maybe, Maybe(..))
 import Data.NonEmpty (NonEmpty, singleton, (:|))
-import Data.String (charAt, toChar)
+import Data.String (charAt)
 import Data.StrMap as SM
-import Data.Traversable (traverse, for)
+import Data.Traversable (traverse)
 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
-  = maybe (Left "fromSpine failed") Right
-  <<< fromSpine
-  <=< gDecodeJson' (toSignature (Proxy :: Proxy a))
-
--- | 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)
-  SigUnit -> pure SUnit
-  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") (SM.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") (SM.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 =<< SM.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
+  decodeJson j =
+      case decode j of
+        Right x -> Right x
+        Left x -> backwardsCompat
+    where
+    decode =
+      decodeJObject >=> lookupJust >=> decodeJson
+    lookupJust =
+        maybe (Left "Missing property 'just'") Right <<< SM.lookup "just"
+    backwardsCompat
+      | isNull j = pure Nothing
+      | otherwise = Just <$> decodeJson j
 
 instance decodeJsonTuple :: (DecodeJson a, DecodeJson b) => DecodeJson (Tuple a b) where
   decodeJson j = decodeJson j >>= f

src/Data/Argonaut/Encode.purs

@@ -3,5 +3,5 @@ module Data.Argonaut.Encode
   , module Data.Argonaut.Encode.Combinators
   ) where
 
-import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson, gEncodeJson, gEncodeJson')
+import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)
 import Data.Argonaut.Encode.Combinators (assoc, extend, (:=), (~>))

src/Data/Argonaut/Encode/Class.purs

@@ -2,11 +2,9 @@ module Data.Argonaut.Encode.Class where
 
 import Prelude
 
-import Data.Argonaut.Core (Json(), jsonNull, fromBoolean, fromNumber, fromString, fromArray, fromObject)
+import Data.Argonaut.Core (Json(), jsonNull, fromBoolean, fromNumber, fromString, fromArray, fromObject, jsonEmptyObject, jsonSingletonObject)
 import Data.Either (Either(), either)
 import Data.Array as Arr
-import Data.Foldable (foldr)
-import Data.Generic (class Generic, GenericSpine(..), toSpine)
 import Data.Int (toNumber)
 import Data.List (List(..), (:), toUnfoldable)
 import Data.List as L
@@ -20,33 +18,9 @@ import Data.Tuple (Tuple(..))
 class EncodeJson a where
   encodeJson :: a -> Json
 
--- | Encode any `Generic` data structure into `Json`.
-gEncodeJson :: forall a. Generic a => a -> Json
-gEncodeJson = gEncodeJson' <<< toSpine
-
--- | Encode `GenericSpine` into `Json`.
-gEncodeJson' :: GenericSpine -> Json
-gEncodeJson' = case _ of
-  SInt x -> fromNumber $ toNumber x
-  SString x -> fromString x
-  SChar x -> fromString $ singleton x
-  SNumber x -> fromNumber x
-  SBoolean x -> fromBoolean x
-  SArray thunks -> fromArray (gEncodeJson' <<< (unit # _) <$> thunks)
-  SUnit -> jsonNull
-  SProd constr args ->
-    fromObject
-      $ SM.insert "tag" (encodeJson constr)
-      $ SM.singleton "values" (encodeJson (gEncodeJson' <<< (unit # _) <$> args))
-  SRecord fields ->
-    fromObject $ foldr addField SM.empty fields
-    where
-    addField field =
-      SM.insert field.recLabel (gEncodeJson' $ field.recValue unit)
-
 instance encodeJsonMaybe :: EncodeJson a => EncodeJson (Maybe a) where
-  encodeJson Nothing  = jsonNull
-  encodeJson (Just a) = encodeJson a
+  encodeJson Nothing  = jsonEmptyObject
+  encodeJson (Just a) = jsonSingletonObject "just" (encodeJson a)
 
 instance encodeJsonTuple :: (EncodeJson a, EncodeJson b) => EncodeJson (Tuple a b) where
   encodeJson (Tuple a b) = encodeJson [encodeJson a, encodeJson b]
@@ -96,7 +70,7 @@ instance encodeStrMap :: EncodeJson a => EncodeJson (SM.StrMap a) where
   encodeJson = fromObject <<< map encodeJson
 
 instance encodeMap :: (Ord a, EncodeJson a, EncodeJson b) => EncodeJson (M.Map a b) where
-  encodeJson = encodeJson <<< M.toList
+  encodeJson = encodeJson <<< (M.toUnfoldable :: M.Map a b -> List (Tuple a b))
 
 instance encodeVoid :: EncodeJson Void where
   encodeJson = absurd