composite-aeson 0.2.0.0 → 0.3.0.0

raw patch · 14 files changed

+72/−65 lines, 14 filesdep +hashabledep −Framesdep −basic-preludePVP ok

version bump matches the API change (PVP)

Dependencies added: hashable

Dependencies removed: Frames, basic-prelude

API changes (from Hackage documentation)

Files

• composite-aeson.cabal +5/−7
• src/Composite/Aeson/Base.hs +1/−1
• src/Composite/Aeson/DateTimeFormatUtils.hs +1/−1
• src/Composite/Aeson/Enum.hs +2/−2
• src/Composite/Aeson/Formats/DateTime.hs +3/−1
• src/Composite/Aeson/Formats/Default.hs +13/−11
• src/Composite/Aeson/Formats/Generic.hs +3/−2
• src/Composite/Aeson/Formats/InternalTH.hs +2/−1
• src/Composite/Aeson/Formats/Provided.hs +14/−10
• src/Composite/Aeson/Record.hs +15/−13
• src/Composite/Aeson/TH.hs +2/−2
• test/Main.hs +0/−1
• test/RecordSpec.hs +11/−12
• test/TupleSpec.hs +0/−1

@@ -3,7 +3,7 @@ -- see: https://github.com/sol/hpack  name:           composite-aeson-version:        0.2.0.0+version:        0.3.0.0 synopsis:       JSON for Vinyl/Frames records description:    Integration between Aeson and Vinyl/Frames records allowing records to be easily converted to JSON using automatic derivation, explicit formats, or a mix of both. category:       Records@@ -18,18 +18,17 @@ library   hs-source-dirs:       src-  default-extensions: DataKinds FlexibleContexts FlexibleInstances GeneralizedNewtypeDeriving LambdaCase MultiParamTypeClasses MultiWayIf NoImplicitPrelude OverloadedStrings PatternSynonyms PolyKinds QuasiQuotes RankNTypes ScopedTypeVariables StandaloneDeriving StrictData TemplateHaskell TupleSections TypeFamilies TypeOperators ViewPatterns+  default-extensions: DataKinds FlexibleContexts FlexibleInstances GeneralizedNewtypeDeriving LambdaCase MultiParamTypeClasses MultiWayIf OverloadedStrings PatternSynonyms PolyKinds QuasiQuotes RankNTypes ScopedTypeVariables StandaloneDeriving StrictData TemplateHaskell TupleSections TypeFamilies TypeOperators ViewPatterns   ghc-options: -Wall -O2   build-depends:       base >= 4.7 && < 5-    , Frames     , aeson     , aeson-better-errors-    , basic-prelude     , composite-base     , containers     , contravariant     , generic-deriving+    , hashable     , lens     , profunctors     , scientific@@ -59,18 +58,17 @@   main-is: Main.hs   hs-source-dirs:       test-  default-extensions: DataKinds FlexibleContexts FlexibleInstances GeneralizedNewtypeDeriving LambdaCase MultiParamTypeClasses MultiWayIf NoImplicitPrelude OverloadedStrings PatternSynonyms PolyKinds QuasiQuotes RankNTypes ScopedTypeVariables StandaloneDeriving StrictData TemplateHaskell TupleSections TypeFamilies TypeOperators ViewPatterns+  default-extensions: DataKinds FlexibleContexts FlexibleInstances GeneralizedNewtypeDeriving LambdaCase MultiParamTypeClasses MultiWayIf OverloadedStrings PatternSynonyms PolyKinds QuasiQuotes RankNTypes ScopedTypeVariables StandaloneDeriving StrictData TemplateHaskell TupleSections TypeFamilies TypeOperators ViewPatterns   ghc-options: -Wall -O2 -threaded -rtsopts -with-rtsopts=-N -fno-warn-orphans   build-depends:       base >= 4.7 && < 5-    , Frames     , aeson     , aeson-better-errors-    , basic-prelude     , composite-base     , containers     , contravariant     , generic-deriving+    , hashable     , lens     , profunctors     , scientific

@@ -4,7 +4,6 @@   , dimapJsonFormat, jsonFormatWithIso, wrappedJsonFormat   ) where -import BasicPrelude import Control.Lens (AnIso', Iso, Wrapped(type Unwrapped), _Wrapped', _Wrapped, iso, over, withIso) import Control.Lens.TH (makeWrapped) import qualified Data.Aeson as Aeson@@ -12,6 +11,7 @@ import qualified Data.Aeson.BetterErrors as ABE import Data.Functor.Contravariant (Contravariant, contramap) import Data.Profunctor (Profunctor(dimap))+import Data.Text (Text) import Data.Void (Void)  -- |Type of functions which take a value @a@ and convert it to an 'Aeson.Value'.

@@ -2,9 +2,9 @@   ( fixupTzIn, fixupTzOut, fixupMs   ) where -import BasicPrelude import Data.Char (isDigit) import Data.Function (fix)+import Data.List (stripPrefix)  -- |Given a string, remove a trailing @Z@ (which is ISO8601 acceptable) and replace it with @+00:00@ (which is @ParseTime@ acceptable) fixupTzIn :: String -> String

@@ -1,12 +1,12 @@ module Composite.Aeson.Enum where -import BasicPrelude import Composite.Aeson.Base (JsonFormat(JsonFormat), JsonProfunctor(JsonProfunctor)) import qualified Data.Aeson as Aeson import qualified Data.Aeson.BetterErrors as ABE import qualified Data.HashMap.Strict as HM+import Data.List (intercalate, stripPrefix) import qualified Data.Map.Strict as M-import Data.Text (pack, unpack)+import Data.Text (Text, pack, unpack) import GHC.Generics (Generic(type Rep)) import Generics.Deriving.ConNames (ConNames, conNames) import Generics.Deriving.Enum (Enum', genumDefault)

@@ -4,10 +4,12 @@   , iso8601DateJsonFormat, iso8601DateTimeJsonFormat, iso8601TimeJsonFormat   ) where -import BasicPrelude import Composite.Aeson.Base (JsonFormat(JsonFormat), JsonProfunctor(JsonProfunctor)) import Composite.Aeson.DateTimeFormatUtils (fixupTzIn, fixupTzOut, fixupMs) import Composite.Aeson.Formats.Provided (stringJsonFormat)+import Data.Either (partitionEithers)+import Data.Monoid ((<>))+import Data.List (intercalate) import Data.List.NonEmpty (NonEmpty((:|))) import qualified Data.List.NonEmpty as NEL import Data.Time.Calendar (Day)

@@ -2,25 +2,28 @@   ( DefaultJsonFormat(..)   ) where -import BasicPrelude import Composite.Aeson.Base (JsonFormat, wrappedJsonFormat)-import Composite.Aeson.Formats.Generic (aesonJsonFormat) import Composite.Aeson.Formats.InternalTH (makeTupleDefaults) import Composite.Aeson.Formats.Provided -- sorry-import Data.Aeson (FromJSON, FromJSONKey, ToJSON, ToJSONKey) import qualified Data.Aeson as Aeson import Data.Functor.Compose (Compose) import Data.Functor.Const (Const) import Data.Functor.Identity (Identity)-import Data.Int (Int8, Int16)+import Data.HashMap.Strict (HashMap)+import Data.Int (Int8, Int16, Int32, Int64)+import Data.IntSet (IntSet) import Data.List.NonEmpty (NonEmpty)+import Data.Map (Map) import qualified Data.Monoid as Monoid import Data.Scientific (Scientific) import qualified Data.Semigroup as Semigroup+import Data.Sequence (Seq) import Data.Tagged (Tagged)+import Data.Text (Text)+import qualified Data.Text.Lazy as TL import Data.Vector (Vector) import Data.Version (Version)-import Data.Word (Word8, Word16)+import Data.Word (Word8, Word16, Word32, Word64) import Numeric.Natural (Natural)  -- |Class for associating a default JSON format with a type.@@ -66,11 +69,10 @@  instance DefaultJsonFormat (f a) => DefaultJsonFormat (Monoid.Alt f a) where defaultJsonFormat = wrappedJsonFormat defaultJsonFormat -instance (FromJSONKey k, ToJSONKey k, Ord k, FromJSON a, ToJSON a) => DefaultJsonFormat (Map k a) where-  defaultJsonFormat = aesonJsonFormat -- because of the insanity that is FromJSONKey / ToJSONKey--instance (FromJSONKey k, ToJSONKey k, Eq k, Hashable k, FromJSON a, ToJSON a) => DefaultJsonFormat (HashMap k a) where-  defaultJsonFormat = aesonJsonFormat -- because of the insanity that is FromJSONKey / ToJSONKey+instance DefaultJsonFormat a => DefaultJsonFormat (Map Text a) where+  defaultJsonFormat = strictMapJsonFormat id pure defaultJsonFormat+instance DefaultJsonFormat a => DefaultJsonFormat (HashMap Text a) where+  defaultJsonFormat = strictHashMapJsonFormat id pure defaultJsonFormat  $makeTupleDefaults @@ -91,7 +93,7 @@ instance DefaultJsonFormat Word16       where defaultJsonFormat = integralJsonFormat instance DefaultJsonFormat Word32       where defaultJsonFormat = integralJsonFormat instance DefaultJsonFormat Word64       where defaultJsonFormat = integralJsonFormat-instance DefaultJsonFormat LText        where defaultJsonFormat = lazyTextJsonFormat+instance DefaultJsonFormat TL.Text      where defaultJsonFormat = lazyTextJsonFormat instance DefaultJsonFormat Natural      where defaultJsonFormat = naturalJsonFormat instance DefaultJsonFormat Ordering     where defaultJsonFormat = orderingJsonFormat instance DefaultJsonFormat Float        where defaultJsonFormat = realFloatJsonFormat

@@ -3,8 +3,8 @@   , SumStyle(..), jsonSumFormat   ) where -import BasicPrelude import Composite.Aeson.Base (JsonFormat(JsonFormat), JsonProfunctor(JsonProfunctor), FromJson(FromJson))+import Control.Arrow (second) import Control.Lens (_Wrapped, over, unsnoc) import Data.Aeson (FromJSON, ToJSON, (.=), toJSON) import qualified Data.Aeson as Aeson@@ -12,7 +12,8 @@ import qualified Data.HashMap.Strict as StrictHashMap import Data.List.NonEmpty (NonEmpty((:|))) import qualified Data.List.NonEmpty as NEL-import Data.Text (unpack)+import Data.Monoid ((<>))+import Data.Text (Text, intercalate, unpack) import qualified Data.Vector as Vector  -- |Produce an explicit 'JsonFormat' by using the implicit Aeson 'ToJSON' instance and an explicit @aeson-better-errors@ 'ABE.Parse'.

@@ -2,10 +2,11 @@   ( makeTupleDefaults, makeTupleFormats   ) where -import BasicPrelude hiding (lift) import Composite.Aeson.Base (JsonFormat(JsonFormat), JsonProfunctor(JsonProfunctor)) import qualified Data.Aeson as Aeson import qualified Data.Aeson.BetterErrors as ABE+import Data.List (foldl')+import Data.Monoid ((<>)) import qualified Data.Vector as V import Language.Haskell.TH   ( Name, mkName, newName, tupleDataName

@@ -1,24 +1,28 @@ -- |Module which provides 'JsonFormat's for a variety of types from @base@ and other common packages. module Composite.Aeson.Formats.Provided where -import BasicPrelude import Composite.Aeson.Base (JsonFormat(JsonFormat), JsonProfunctor(JsonProfunctor), _JsonProfunctor, dimapJsonFormat, toJsonWithFormat) import Composite.Aeson.Formats.Generic (SumStyle, abeJsonFormat, aesonJsonFormat, jsonArrayFormat, jsonObjectFormat, jsonSumFormat) import Composite.Aeson.Formats.InternalTH (makeTupleFormats)+import Control.Arrow (first) import Control.Lens (_2, _Wrapped, over, view) import qualified Data.Aeson as Aeson import qualified Data.Aeson.BetterErrors as ABE import Data.Fixed (HasResolution, Fixed) import Data.Foldable (toList)+import Data.Hashable (Hashable) import qualified Data.HashMap.Lazy as LazyHashMap import qualified Data.HashMap.Strict as StrictHashMap+import Data.IntSet (IntSet) import Data.List.NonEmpty (NonEmpty((:|))) import qualified Data.List.NonEmpty as NEL import qualified Data.Map.Lazy as LazyMap import qualified Data.Map.Strict as StrictMap import Data.Scientific (Scientific) import qualified Data.Scientific as Scientific+import Data.Sequence (Seq) import qualified Data.Sequence as Sequence+import Data.Text (Text) import qualified Data.Text.Lazy as LT import qualified Data.Vector as V import Data.Version (Version)@@ -62,14 +66,14 @@ -- |'JsonFormat' for 'StrictHashMap.HashMap' where the key type can be converted to and from a 'Text', mapping to a JSON object. strictHashMapJsonFormat :: (Eq k, Hashable k) => (k -> Text) -> (Text -> ABE.Parse e k) -> JsonFormat e a -> JsonFormat e (StrictHashMap.HashMap k a) strictHashMapJsonFormat kToText kFromText =-  jsonObjectFormat (map (first kToText) . StrictHashMap.toList)-                   (map StrictHashMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))+  jsonObjectFormat (fmap (first kToText) . StrictHashMap.toList)+                   (fmap StrictHashMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))  -- |'JsonFormat' for 'LazyHashMap.HashMap' where the key type can be converted to and from a 'Text', mapping to a JSON object. lazyHashMapJsonFormat :: (Eq k, Hashable k) => (k -> Text) -> (Text -> ABE.Parse e k) -> JsonFormat e a -> JsonFormat e (LazyHashMap.HashMap k a) lazyHashMapJsonFormat kToText kFromText =-  jsonObjectFormat (map (first kToText) . LazyHashMap.toList)-                   (map LazyHashMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))+  jsonObjectFormat (fmap (first kToText) . LazyHashMap.toList)+                   (fmap LazyHashMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))  -- |'JsonFormat' for 'IntSet' which maps to an array of numbers. intSetJsonFormat :: JsonFormat e IntSet@@ -90,14 +94,14 @@ -- |'JsonFormat' for 'StrictMap.Map' where the key type can be converted to and from a 'Text', mapping to a JSON object. strictMapJsonFormat :: Ord k => (k -> Text) -> (Text -> ABE.Parse e k) -> JsonFormat e a -> JsonFormat e (StrictMap.Map k a) strictMapJsonFormat kToText kFromText =-  jsonObjectFormat (map (first kToText) . StrictMap.toAscList)-                   (map StrictMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))+  jsonObjectFormat (fmap (first kToText) . StrictMap.toAscList)+                   (fmap StrictMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))  -- |'JsonFormat' for 'LazyMap.Map' where the key type can be converted to and from a 'Text', mapping to a JSON object. lazyMapJsonFormat :: Ord k => (k -> Text) -> (Text -> ABE.Parse e k) -> JsonFormat e a -> JsonFormat e (LazyMap.Map k a) lazyMapJsonFormat kToText kFromText =-  jsonObjectFormat (map (first kToText) . LazyMap.toAscList)-                   (map LazyMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))+  jsonObjectFormat (fmap (first kToText) . LazyMap.toAscList)+                   (fmap LazyMap.fromList . traverse (\ (k, a) -> (, a) <$> kFromText k))  -- |'JsonFormat' for 'Maybe' which maps @Nothing@ to @null@. maybeJsonFormat :: JsonFormat e a -> JsonFormat e (Maybe a)@@ -167,7 +171,7 @@ vectorJsonFormat (JsonFormat (JsonProfunctor oA iA)) =   JsonFormat (JsonProfunctor o i)   where-    o = Aeson.Array . map oA+    o = Aeson.Array . fmap oA     i = V.fromList <$> ABE.eachInArray iA  -- |'JsonFormat' for 'Version' which maps to a string.

@@ -1,21 +1,23 @@ module Composite.Aeson.Record where -import BasicPrelude import Composite.Aeson.Base   ( JsonProfunctor(JsonProfunctor)   , JsonFormat(JsonFormat)   , wrappedJsonFormat   )-import Composite.Base (NamedField(fieldName)) import Composite.Aeson.Formats.Default (DefaultJsonFormat(defaultJsonFormat))+import Composite.Record ((:->)) import Control.Lens (Wrapped(type Unwrapped, _Wrapped'), from, view)+import Control.Monad (join) import qualified Data.Aeson as Aeson import qualified Data.Aeson.BetterErrors as ABE import Data.Functor.Contravariant (Contravariant, contramap)+import Data.Functor.Identity (Identity(Identity)) import qualified Data.HashMap.Strict as HM import Data.Proxy (Proxy(Proxy))+import Data.Text (Text, pack) import Data.Vinyl (Rec((:&), RNil), rmap)-import Data.Vinyl.Functor (Identity(Identity))+import GHC.TypeLits (KnownSymbol, symbolVal)  -- |Function to encode a single field of a record, possibly choosing to elide the field with @Nothing@. newtype ToField a = ToField { unToField :: a -> Maybe Aeson.Value }@@ -46,7 +48,7 @@ optionalField :: forall e a a'. (Wrapped a', Unwrapped a' ~ Maybe a) => JsonFormat e a -> JsonField e a' optionalField (JsonFormat (JsonProfunctor o i)) =   JsonField-    (map o . view _Wrapped')+    (fmap o . view _Wrapped')     (\ k -> view (from _Wrapped') . join <$> ABE.keyMay k (ABE.perhaps i))  -- |Given a 'JsonFormat' for some type @a@, produce a 'JsonField' for fields of type @Maybe a@ which substitutes @Nothing@ for either @null@ or missing field,@@ -54,7 +56,7 @@ optionalField' :: JsonFormat e a -> JsonField e (Maybe a) optionalField' (JsonFormat (JsonProfunctor o i)) =   JsonField-    (map o)+    (fmap o)     (\ k -> join <$> ABE.keyMay k (ABE.perhaps i))  -- |Type of a Vinyl/Frames record which describes how to map fields of a record to JSON and back.@@ -72,8 +74,8 @@ -- @ --   userFormatRec :: 'JsonFormatRec' e User --   userFormatRec = 'field' 'Composite.Aeson.Default.integralJsonFormat'---                &: 'field' 'Composite.Aeson.Default.textJsonFormat'---                &: Nil+--               :^: 'field' 'Composite.Aeson.Default.textJsonFormat'+--               :^: RNil -- @ -- -- Or, using the default mappings for each field type:@@ -109,14 +111,14 @@ instance RecToJsonObject '[] where   recToJsonObject _ = const mempty -instance forall r rs. (NamedField r, RecToJsonObject rs) => RecToJsonObject (r ': rs) where+instance forall s a rs. (KnownSymbol s, RecToJsonObject rs) => RecToJsonObject (s :-> a ': rs) where   recToJsonObject (ToField aToField :& fs) (Identity a :& as) =-    maybe id (HM.insert (fieldName (Proxy :: Proxy r))) (aToField a) $+    maybe id (HM.insert (pack . symbolVal $ (Proxy :: Proxy s))) (aToField a) $       recToJsonObject fs as  -- |Given a record of 'ToField' functions for each field in @rs@, convert an 'Identity' record to JSON. Equivalent to @Aeson.Object . 'recToJsonObject' fmt@ recToJson :: RecToJsonObject rs => Rec ToField rs -> Rec Identity rs -> Aeson.Value-recToJson = map Aeson.Object . recToJsonObject+recToJson = fmap Aeson.Object . recToJsonObject  -- |Class which induces over the structure of a record, parsing fields using a record of 'FromJson' and assembling an 'Identity' record. class RecFromJson rs where@@ -126,10 +128,10 @@ instance RecFromJson '[] where   recFromJson _ = pure RNil -instance forall r rs. (NamedField r, RecFromJson rs) => RecFromJson (r ': rs) where+instance forall s a rs. (KnownSymbol s, RecFromJson rs) => RecFromJson (s :-> a ': rs) where   recFromJson (FromField aFromField :& fs) =     (:&)-      <$> (Identity <$> aFromField (fieldName (Proxy :: Proxy r)))+      <$> (Identity <$> aFromField (pack . symbolVal $ (Proxy :: Proxy s)))       <*> recFromJson fs  -- |Take a 'JsonFormatRec' describing how to map a record with field @rs@ to and from JSON and produce a @'JsonFormat' e (Record rs)@.@@ -146,7 +148,7 @@   -- |Produce a 'JsonFormatRec' for a record with fields @rs@ by using the default 'JsonFormat' for each field in @rs@, as provided by 'DefaultJsonFormat'.   defaultJsonFormatRec :: JsonFormatRec e rs -instance (NamedField r, DefaultJsonFormat (Unwrapped r), DefaultJsonFormatRec rs) => DefaultJsonFormatRec (r ': rs) where+instance (KnownSymbol s, DefaultJsonFormat a, DefaultJsonFormatRec rs) => DefaultJsonFormatRec (s :-> a ': rs) where   defaultJsonFormatRec = field defaultJsonFormat :& defaultJsonFormatRec  instance DefaultJsonFormatRec '[] where

@@ -3,13 +3,13 @@   , makeRecJsonWrapperExplicit   ) where -import BasicPrelude import Composite.Aeson.Base (JsonFormat, dimapJsonFormat, parseJsonWithFormat', toJsonWithFormat) import Composite.Aeson.Record (defaultJsonFormatRec, recJsonFormat)+import Composite.Record (Record) import Control.Lens (_head, over) import Data.Aeson (FromJSON(parseJSON), ToJSON(toJSON)) import Data.Char (toLower)-import Frames (Record)+import Data.Monoid ((<>)) import Language.Haskell.TH   ( Q, clause, cxt   , normalB

@@ -1,4 +1,3 @@-import BasicPrelude import RecordSpec (recordSuite) import TupleSpec (tupleSuite) import Test.Hspec (hspec)

@@ -1,6 +1,6 @@ module RecordSpec where -import BasicPrelude+import Composite (Rec(RNil), Record, (:->), pattern (:*:)) import Composite.Aeson.Base (JsonFormat, fromJsonWithFormat, toJsonWithFormat) import Composite.Aeson.Formats.Provided (stringJsonFormat) import Composite.Aeson.Record (defaultJsonFormatRec, recJsonFormat, optionalField)@@ -10,7 +10,6 @@ import Data.Aeson.QQ (aesonQQ) import Data.Vinyl.Lens (rlens) import Data.Void (Void)-import Frames (Record, (:->), (&:), pattern Nil) import Test.Hspec (Spec, describe, it, shouldBe, shouldNotBe)  withLensesAndProxies [d|@@ -27,19 +26,19 @@         optionalFmt = recJsonFormat $ set (rlens fBar_) (optionalField stringJsonFormat) defaultJsonFormatRec      it "by default requires all fields" $ do-      parseValue (fromJsonWithFormat defaultFmt) [aesonQQ| {foo: 123, bar: "abc"} |] `shouldBe`    Right (123 &: Just "abc" &: Nil)-      parseValue (fromJsonWithFormat defaultFmt) [aesonQQ| {foo: 123, bar: null}  |] `shouldBe`    Right (123 &: Nothing    &: Nil)-      parseValue (fromJsonWithFormat defaultFmt) [aesonQQ| {foo: 123}             |] `shouldNotBe` Right (123 &: Nothing    &: Nil)+      parseValue (fromJsonWithFormat defaultFmt) [aesonQQ| {foo: 123, bar: "abc"} |] `shouldBe`    Right (123 :*: Just "abc" :*: RNil)+      parseValue (fromJsonWithFormat defaultFmt) [aesonQQ| {foo: 123, bar: null}  |] `shouldBe`    Right (123 :*: Nothing    :*: RNil)+      parseValue (fromJsonWithFormat defaultFmt) [aesonQQ| {foo: 123}             |] `shouldNotBe` Right (123 :*: Nothing    :*: RNil)      it "by default encodes all fields" $ do-      toJsonWithFormat defaultFmt (123 &: Just "abc" &: Nil) `shouldBe` [aesonQQ| {foo: 123, bar: "abc"} |]-      toJsonWithFormat defaultFmt (123 &: Nothing    &: Nil) `shouldBe` [aesonQQ| {foo: 123, bar: null}  |]+      toJsonWithFormat defaultFmt (123 :*: Just "abc" :*: RNil) `shouldBe` [aesonQQ| {foo: 123, bar: "abc"} |]+      toJsonWithFormat defaultFmt (123 :*: Nothing    :*: RNil) `shouldBe` [aesonQQ| {foo: 123, bar: null}  |]      it "can make fields optional" $ do-      parseValue (fromJsonWithFormat optionalFmt) [aesonQQ| {foo: 123, bar: "abc"} |] `shouldBe` Right (123 &: Just "abc" &: Nil)-      parseValue (fromJsonWithFormat optionalFmt) [aesonQQ| {foo: 123, bar: null}  |] `shouldBe` Right (123 &: Nothing    &: Nil)-      parseValue (fromJsonWithFormat optionalFmt) [aesonQQ| {foo: 123}             |] `shouldBe` Right (123 &: Nothing    &: Nil)+      parseValue (fromJsonWithFormat optionalFmt) [aesonQQ| {foo: 123, bar: "abc"} |] `shouldBe` Right (123 :*: Just "abc" :*: RNil)+      parseValue (fromJsonWithFormat optionalFmt) [aesonQQ| {foo: 123, bar: null}  |] `shouldBe` Right (123 :*: Nothing    :*: RNil)+      parseValue (fromJsonWithFormat optionalFmt) [aesonQQ| {foo: 123}             |] `shouldBe` Right (123 :*: Nothing    :*: RNil)      it "omits Nothing fields when they're made optional" $ do-      toJsonWithFormat optionalFmt (123 &: Just "abc" &: Nil) `shouldBe` [aesonQQ| {foo: 123, bar: "abc"} |]-      toJsonWithFormat optionalFmt (123 &: Nothing    &: Nil) `shouldBe` [aesonQQ| {foo: 123}             |]+      toJsonWithFormat optionalFmt (123 :*: Just "abc" :*: RNil) `shouldBe` [aesonQQ| {foo: 123, bar: "abc"} |]+      toJsonWithFormat optionalFmt (123 :*: Nothing    :*: RNil) `shouldBe` [aesonQQ| {foo: 123}             |]

@@ -1,6 +1,5 @@ module TupleSpec where -import BasicPrelude import Composite.Aeson.Base (JsonFormat, fromJsonWithFormat, toJsonWithFormat) import Composite.Aeson.Formats.Provided (tuple3JsonFormat, integralJsonFormat, stringJsonFormat, charJsonFormat) import Data.Aeson.BetterErrors (parseValue)