purescript-bridge 0.14.0.0 → 0.15.0.0

raw patch · 11 files changed

+300/−78 lines, 11 filesnew-uploaderPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• README.md +10/−3
• purescript-bridge.cabal +1/−1
• src/Language/PureScript/Bridge.hs +6/−0
• src/Language/PureScript/Bridge/Builder.hs +1/−0
• src/Language/PureScript/Bridge/CodeGenSwitches.hs +13/−9
• src/Language/PureScript/Bridge/PSTypes.hs +45/−0
• src/Language/PureScript/Bridge/Primitives.hs +18/−0
• src/Language/PureScript/Bridge/Printer.hs +108/−36
• src/Language/PureScript/Bridge/SumType.hs +2/−4
• test/Spec.hs +94/−25
• test/TestData.hs +2/−0

@@ -1,7 +1,7 @@ # purescript-bridge  -[![Build Status](https://travis-ci.org/eskimor/purescript-bridge.svg?branch=master)](https://travis-ci.org/eskimor/purescript-bridge)+[![Haskell library and example](https://github.com/eskimor/purescript-bridge/actions/workflows/haskell.yml/badge.svg)](https://github.com/eskimor/purescript-bridge/actions/workflows/haskell.yml) [![Purescript example](https://github.com/eskimor/purescript-bridge/actions/workflows/purescript.yml/badge.svg)](https://github.com/eskimor/purescript-bridge/actions/workflows/purescript.yml) [![Build Status](https://travis-ci.org/eskimor/purescript-bridge.svg?branch=master)](https://travis-ci.org/eskimor/purescript-bridge)   @@ -10,11 +10,18 @@  Data type translation is fully and easily customizable by providing your own `BridgePart` instances! +The latest version of this project requires **Purescript 0.15**.+ ## JSON encoding / decoding -For compatible JSON representations you should be using [aeson](http://hackage.haskell.org/package/aeson)'s generic encoding/decoding with default options-and `encodeJson` and `decodeJson` from "Data.Argonaut.Generic.Aeson" in [purescript-argonaut-generic-codecs](https://github.com/eskimor/purescript-argonaut-generic-codecs).+For compatible JSON representations: +* On Haskell side:+  * Use [`aeson`](http://hackage.haskell.org/package/aeson)'s generic encoding/decoding with default options+* On Purescript side:+  * Use [`purescript-argonaut-aeson-generic >=0.4.1`](https://pursuit.purescript.org/packages/purescript-argonaut-aeson-generic/0.4.1) ([GitHub](https://github.com/coot/purescript-argonaut-aeson-generic))+  * Or use [`purescript-foreign-generic`](https://pursuit.purescript.org/packages/purescript-foreign-generic).+    * [This branch](https://github.com/paf31/purescript-foreign-generic/pull/76) is updated for Purescript 0.15.  ## Documentation 

@@ -10,7 +10,7 @@ -- PVP summary:      +-+------- breaking API changes --                   | | +----- non-breaking API additions --                   | | | +--- code changes with no API change-version:             0.14.0.0+version:             0.15.0.0  -- A short (one-line) description of the package. synopsis:            Generate PureScript data types from Haskell data types

@@ -130,12 +130,18 @@     <|> listBridge     <|> maybeBridge     <|> eitherBridge+    <|> strMapBridge     <|> boolBridge     <|> intBridge     <|> doubleBridge     <|> tupleBridge     <|> unitBridge     <|> noContentBridge+    <|> wordBridge+    <|> word8Bridge+    <|> word16Bridge+    <|> word32Bridge+    <|> word64Bridge  -- | Translate types in a constructor. bridgeConstructor :: FullBridge -> DataConstructor 'Haskell -> DataConstructor 'PureScript

@@ -43,6 +43,7 @@ import           Control.Monad.Trans.Reader          (Reader, ReaderT (..),                                                       runReader) import           Data.Maybe                          (fromMaybe)+import           Data.Monoid ((<>)) import qualified Data.Text                           as T import           Language.PureScript.Bridge.TypeInfo 

@@ -3,13 +3,13 @@     ( Settings (..)     , ForeignOptions(..)     , defaultSettings-    , purs_0_11_settings     , Switch     , getSettings     , defaultSwitch     , noLenses, genLenses     , useGen, useGenRep-    , genForeign, noForeign+    , genForeign, noForeign, noArgonautCodecs+    , genArgonautCodecs     ) where  @@ -19,24 +19,20 @@ data Settings = Settings     { generateLenses :: Bool -- ^use purescript-profunctor-lens for generated PS-types?     , genericsGenRep :: Bool -- ^generate generics using purescript-generics-rep instead of purescript-generics+    , generateArgonautCodecs :: Bool -- ^generate Data.Argonaut.Decode.Class EncodeJson and DecodeJson instances     , generateForeign :: Maybe ForeignOptions -- ^generate Foreign.Generic Encode and Decode instances     }     deriving (Eq, Show)  data ForeignOptions = ForeignOptions     { unwrapSingleConstructors :: Bool+    , unwrapSingleArguments    :: Bool     }     deriving (Eq, Show)  -- | Settings to generate Lenses defaultSettings :: Settings-defaultSettings = Settings True True Nothing----- |settings for purescript 0.11.x-purs_0_11_settings :: Settings-purs_0_11_settings = Settings True False Nothing-+defaultSettings = Settings True True True Nothing  -- | you can `mappend` switches to control the code generation type Switch = Endo Settings@@ -56,6 +52,10 @@ noLenses :: Switch noLenses = Endo $ \settings -> settings { generateLenses = False } +-- | Switch off the generatation of argonaut-codecs+noArgonautCodecs :: Switch+noArgonautCodecs = Endo $ \settings ->+  settings { generateArgonautCodecs = False }  -- | Switch on the generatation of profunctor-lenses genLenses :: Switch@@ -73,6 +73,10 @@  genForeign :: ForeignOptions -> Switch genForeign opts = Endo $ \settings -> settings { generateForeign = Just opts }++genArgonautCodecs :: Switch+genArgonautCodecs = Endo $ \settings ->+  settings { generateArgonautCodecs = True }  noForeign :: Switch noForeign = Endo $ \settings -> settings { generateForeign = Nothing }

@@ -31,6 +31,11 @@ psEither :: MonadReader BridgeData m => m PSType psEither = TypeInfo "purescript-either" "Data.Either" "Either" <$> psTypeParameters +psObject :: MonadReader BridgeData m => m PSType+psObject = do+  valueTypes <- tail <$> psTypeParameters+  return $ TypeInfo "purescript-foreign-object" "Foreign.Object" "Object" valueTypes+ psInt :: PSType psInt = TypeInfo {     _typePackage = ""@@ -73,5 +78,45 @@     _typePackage = "purescript-prelude"   , _typeModule = "Prelude"   , _typeName = "Unit"+  , _typeParameters = []+  }++psWord :: PSType+psWord = TypeInfo  {+    _typePackage = "purescript-word"+  , _typeModule = "Data.Word"+  , _typeName = "Word"+  , _typeParameters = []+  }++psWord8 :: PSType+psWord8 = TypeInfo  {+    _typePackage = "purescript-word"+  , _typeModule = "Data.Word"+  , _typeName = "Word8"+  , _typeParameters = []+  }++psWord16 :: PSType+psWord16 = TypeInfo  {+    _typePackage = "purescript-word"+  , _typeModule = "Data.Word"+  , _typeName = "Word16"+  , _typeParameters = []+  }++psWord32 :: PSType+psWord32 = TypeInfo  {+    _typePackage = "purescript-word"+  , _typeModule = "Data.Word"+  , _typeName = "Word32"+  , _typeParameters = []+  }++psWord64 :: PSType+psWord64 = TypeInfo  {+    _typePackage = "purescript-word"+  , _typeModule = "Data.Word"+  , _typeName = "Word64"   , _typeParameters = []   }

@@ -19,6 +19,9 @@ eitherBridge :: BridgePart eitherBridge = typeName ^== "Either" >> psEither +strMapBridge :: BridgePart+strMapBridge = typeName ^== "Map" >> psObject+ -- | Dummy bridge, translates every type with 'clearPackageFixUp' dummyBridge :: MonadReader BridgeData m => m PSType dummyBridge = clearPackageFixUp@@ -49,3 +52,18 @@  noContentBridge :: BridgePart noContentBridge = typeName ^== "NoContent" >> return psUnit++wordBridge :: BridgePart+wordBridge = typeName ^== "Word" >> return psWord++word8Bridge :: BridgePart+word8Bridge = typeName ^== "Word8" >> return psWord8++word16Bridge :: BridgePart+word16Bridge = typeName ^== "Word16" >> return psWord16++word32Bridge :: BridgePart+word32Bridge = typeName ^== "Word32" >> return psWord32++word64Bridge :: BridgePart+word64Bridge = typeName ^== "Word64" >> return psWord64

@@ -1,6 +1,8 @@ {-# LANGUAGE DataKinds         #-} {-# LANGUAGE KindSignatures    #-} {-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RecordWildCards   #-}+{-# LANGUAGE LambdaCase        #-}  module Language.PureScript.Bridge.Printer where @@ -8,6 +10,7 @@ import           Control.Monad import           Data.Map.Strict (Map) import qualified Data.Map.Strict as Map+import           Data.Monoid ((<>)) import           Data.Set (Set) import           Data.Maybe (isJust) import qualified Data.Set as Set@@ -17,7 +20,6 @@ import           System.Directory import           System.FilePath - import           Language.PureScript.Bridge.SumType import           Language.PureScript.Bridge.TypeInfo import qualified Language.PureScript.Bridge.CodeGenSwitches as Switches@@ -33,6 +35,7 @@  data ImportLine = ImportLine {   importModule :: !Text+, importAlias  :: !(Maybe Text) , importTypes  :: !(Set Text) } deriving Show @@ -66,45 +69,63 @@      ]   <> map (sumTypeToText settings) (psTypes m)   where-    otherImports = importsFromList (_lensImports settings <> _genericsImports settings <> _foreignImports settings)+    otherImports = importsFromList $+      _lensImports settings+      <> _genericsImports settings+      <> _argonautCodecsImports settings+      <> _foreignImports settings     allImports = Map.elems $ mergeImportLines otherImports (psImportLines m) - _genericsImports :: Switches.Settings -> [ImportLine] _genericsImports settings   | Switches.genericsGenRep settings =-     [ ImportLine "Data.Generic.Rep" $ Set.fromList ["class Generic"] ]+     [ ImportLine "Data.Generic.Rep" Nothing $ Set.fromList ["class Generic"] ]   | otherwise =-    [ ImportLine "Data.Generic" $ Set.fromList ["class Generic"] ]-+    [ ImportLine "Data.Generic" Nothing $ Set.fromList ["class Generic"] ]  _lensImports :: Switches.Settings -> [ImportLine] _lensImports settings   | Switches.generateLenses settings =-    [ ImportLine "Data.Maybe" $ Set.fromList ["Maybe(..)"]-    , ImportLine "Data.Lens" $ Set.fromList ["Iso'", "Prism'", "Lens'", "prism'", "lens"]-    , ImportLine "Data.Lens.Record" $ Set.fromList ["prop"]-    , ImportLine "Data.Lens.Iso.Newtype" $ Set.fromList ["_Newtype"]-    , ImportLine "Data.Symbol" $ Set.fromList ["SProxy(SProxy)"]-    , ImportLine "Data.Newtype" $ Set.fromList ["class Newtype"]+    [ ImportLine "Data.Lens" Nothing $ Set.fromList ["Iso'", "Prism'", "Lens'", "prism'", "lens"]+    , ImportLine "Data.Lens.Iso.Newtype" Nothing $ Set.fromList ["_Newtype"]+    , ImportLine "Data.Lens.Record" Nothing $ Set.fromList ["prop"]+    ] <> baseline <>+    [ ImportLine "Type.Proxy" Nothing $ Set.fromList ["Proxy(Proxy)"]     ]-  | otherwise =-    [ ImportLine "Data.Maybe" $ Set.fromList ["Maybe(..)"]-    , ImportLine "Data.Newtype" $ Set.fromList ["class Newtype"]+  | otherwise = baseline+  where+    baseline =+      [ ImportLine "Data.Maybe" Nothing $ Set.fromList ["Maybe(..)"]+      , ImportLine "Data.Newtype" Nothing $ Set.fromList ["class Newtype"]+      ]++_argonautCodecsImports :: Switches.Settings -> [ImportLine]+_argonautCodecsImports settings+  | Switches.generateArgonautCodecs settings =+    [ ImportLine "Data.Argonaut.Aeson.Decode.Generic" Nothing $ Set.fromList [ "genericDecodeAeson" ]+    , ImportLine "Data.Argonaut.Aeson.Encode.Generic" Nothing $ Set.fromList [ "genericEncodeAeson" ]+    , ImportLine "Data.Argonaut.Aeson.Options" (Just "Argonaut") $ Set.fromList [ "defaultOptions" ]+    , ImportLine "Data.Argonaut.Decode.Class" Nothing $ Set.fromList [ "class DecodeJson", "class DecodeJsonField", "decodeJson" ]+    , ImportLine "Data.Argonaut.Encode.Class" Nothing $ Set.fromList [ "class EncodeJson", "encodeJson" ]     ]+  | otherwise = mempty  _foreignImports :: Switches.Settings -> [ImportLine] _foreignImports settings   | (isJust . Switches.generateForeign) settings = -      [ ImportLine "Foreign.Generic" $ Set.fromList ["defaultOptions", "genericDecode", "genericEncode"]-      , ImportLine "Foreign.Class" $ Set.fromList ["class Decode", "class Encode"]+      [ ImportLine "Foreign.Class" Nothing $ Set.fromList ["class Decode", "class Encode"]+      , ImportLine "Foreign.Generic" Nothing $ Set.fromList ["defaultOptions", "genericDecode", "genericEncode"]       ]-  | otherwise = []+  | otherwise = mempty  importLineToText :: ImportLine -> Text-importLineToText l = "import " <> importModule l <> " (" <> typeList <> ")"+importLineToText = \case+  ImportLine importModule Nothing importTypes ->+    "import " <> importModule <> " (" <> typeList importTypes <> ")"+  ImportLine importModule (Just importAlias) _ ->+    "import " <> importModule <> " as " <> importAlias   where-    typeList = T.intercalate ", " (Set.toList (importTypes l))+    typeList s = T.intercalate ", " (Set.toList s)  sumTypeToText :: Switches.Settings -> SumType 'PureScript -> Text sumTypeToText settings st =@@ -119,13 +140,35 @@ sumTypeToTypeDecls settings (SumType t cs is) = T.unlines $     dataOrNewtype <> " " <> typeInfoToText True t <> " ="   : "    " <> T.intercalate "\n  | " (map (constructorToText 4) cs) <> "\n"-  : instances settings (SumType t cs (filter genForeign is))+  : instances settings (SumType t cs (filter genForeign . filter genArgonautCodec $ is))   where     dataOrNewtype = if isJust (nootype cs) then "newtype" else "data"-    genForeign Encode = (isJust . Switches.generateForeign) settings-    genForeign Decode = (isJust . Switches.generateForeign) settings-    genForeign _ = True+    genForeign :: Instance -> Bool+    genForeign = \case+      Encode -> check+      Decode -> check+      _      -> True+      where check = (isJust . Switches.generateForeign) settings +    genArgonautCodec :: Instance -> Bool+    genArgonautCodec = \case+      EncodeJson -> check+      DecodeJson -> check+      _          -> True+      where check = Switches.generateArgonautCodecs settings++foreignOptionsToPurescript :: Maybe Switches.ForeignOptions -> Text+foreignOptionsToPurescript = \case+  Nothing -> mempty+  Just (Switches.ForeignOptions{..}) ->+    " { unwrapSingleConstructors = "+    <> (T.toLower . T.pack . show $ unwrapSingleConstructors)+    <> " , unwrapSingleArguments = "+    <> (T.toLower . T.pack . show $ unwrapSingleArguments)+    <> " }"+++ -- | Given a Purescript type, generate instances for typeclass -- instances it claims to have. instances :: Switches.Settings -> SumType 'PureScript -> [Text]@@ -135,9 +178,8 @@     go Encode = "instance encode" <> _typeName t <> " :: " <> extras <> "Encode " <> typeInfoToText False t <> " where\n" <>                 "  encode = genericEncode $ defaultOptions" <> encodeOpts       where-        encodeOpts = case Switches.generateForeign settings of-                      Nothing -> ""-                      Just fopts -> " { unwrapSingleConstructors = " <> (T.toLower . T.pack . show . Switches.unwrapSingleConstructors) fopts <> " }"+        encodeOpts =+          foreignOptionsToPurescript $ Switches.generateForeign settings         stpLength = length sumTypeParameters         extras | stpLength == 0 = mempty                | otherwise = bracketWrap constraintsInner <> " => "@@ -145,12 +187,23 @@         constraintsInner = T.intercalate ", " $ map instances sumTypeParameters         instances params = genericInstance settings params <> ", " <> encodeInstance params         bracketWrap x = "(" <> x <> ")"+    go EncodeJson = "instance encodeJson" <> _typeName t <> " :: " <> extras <> "EncodeJson " <> typeInfoToText False t <> " where\n" <>+                "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+      where+        encodeOpts =+          foreignOptionsToPurescript $ Switches.generateForeign settings+        stpLength = length sumTypeParameters+        extras | stpLength == 0 = mempty+               | otherwise = bracketWrap constraintsInner <> " => "+        sumTypeParameters = filter (isTypeParam t) . Set.toList $ getUsedTypes st+        constraintsInner = T.intercalate ", " $ map instances sumTypeParameters+        instances params = genericInstance settings params <> ", " <> encodeJsonInstance params+        bracketWrap x = "(" <> x <> ")"     go Decode = "instance decode" <> _typeName t <> " :: " <> extras <> "Decode " <> typeInfoToText False t <> " where\n" <>                 "  decode = genericDecode $ defaultOptions" <> decodeOpts       where-        decodeOpts = case Switches.generateForeign settings of-                      Nothing -> ""-                      Just fopts -> " { unwrapSingleConstructors = " <> (T.toLower . T.pack . show . Switches.unwrapSingleConstructors) fopts <> " }"+        decodeOpts =+          foreignOptionsToPurescript $ Switches.generateForeign settings         stpLength = length sumTypeParameters         extras | stpLength == 0 = mempty                | otherwise = bracketWrap constraintsInner <> " => "@@ -158,6 +211,16 @@         constraintsInner = T.intercalate ", " $ map instances sumTypeParameters         instances params = genericInstance settings params <> ", " <> decodeInstance params         bracketWrap x = "(" <> x <> ")"+    go DecodeJson = "instance decodeJson" <> _typeName t <> " :: " <> extras <> "DecodeJson " <> typeInfoToText False t <> " where\n" <>+                "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+      where+        stpLength = length sumTypeParameters+        extras | stpLength == 0 = mempty+               | otherwise = bracketWrap constraintsInner <> " => "+        sumTypeParameters = filter (isTypeParam t) . Set.toList $ getUsedTypes st+        constraintsInner = T.intercalate ", " $ map instances sumTypeParameters+        instances params = genericInstance settings params <> ", " <> decodeJsonInstance params <> ", " <> decodeJsonFieldInstance params+        bracketWrap x = "(" <> x <> ")"     go i = "derive instance " <> T.toLower c <> _typeName t <> " :: " <> extras i <> c <> " " <> typeInfoToText False t <> postfix i       where c = T.pack $ show i             extras Generic | stpLength == 0 = mempty@@ -180,9 +243,18 @@ encodeInstance :: PSType -> Text encodeInstance params = "Encode " <> typeInfoToText False params +encodeJsonInstance :: PSType -> Text+encodeJsonInstance params = "EncodeJson " <> typeInfoToText False params+ decodeInstance :: PSType -> Text decodeInstance params = "Decode " <> typeInfoToText False params +decodeJsonInstance :: PSType -> Text+decodeJsonInstance params = "DecodeJson " <> typeInfoToText False params++decodeJsonFieldInstance :: PSType -> Text+decodeJsonFieldInstance params = "DecodeJsonField " <> typeInfoToText False params+ genericInstance :: Switches.Settings -> PSType -> Text genericInstance settings params =   if not (Switches.genericsGenRep settings) then@@ -227,7 +299,6 @@ spaces :: Int -> Text spaces c = T.replicate c " " - typeNameAndForall :: TypeInfo 'PureScript -> (Text, Text) typeNameAndForall typeInfo = (typName, forAll)   where@@ -297,7 +368,7 @@ recordEntryToLens st e =   if hasUnderscore   then lensName <> forAll <>  "Lens' " <> typName <> " " <> recType <> "\n"-      <> lensName <> " = _Newtype <<< prop (SProxy :: SProxy \"" <> recName <> "\")\n"+      <> lensName <> " = _Newtype <<< prop (Proxy :: Proxy \"" <> recName <> "\")\n"   else ""   where     (typName, forAll) = typeNameAndForall (st ^. sumTypeInfo)@@ -356,20 +427,21 @@                 then Map.alter (Just . updateLine) (_typeModule t)                 else id -    updateLine Nothing = ImportLine (_typeModule t) (Set.singleton (_typeName t))-    updateLine (Just (ImportLine m types)) = ImportLine m $ Set.insert (_typeName t) types+    updateLine Nothing = ImportLine (_typeModule t) Nothing (Set.singleton (_typeName t))+    updateLine (Just (ImportLine m alias types)) =+      ImportLine m alias (Set.insert (_typeName t) types)  importsFromList :: [ImportLine] -> Map Text ImportLine importsFromList ls = let     pairs = zip (map importModule ls) ls-    merge a b = ImportLine (importModule a) (importTypes a `Set.union` importTypes b)+    merge a b = ImportLine (importModule a) (importAlias a) (importTypes a `Set.union` importTypes b)   in     Map.fromListWith merge pairs  mergeImportLines :: ImportLines -> ImportLines -> ImportLines mergeImportLines = Map.unionWith mergeLines   where-    mergeLines a b = ImportLine (importModule a) (importTypes a `Set.union` importTypes b)+    mergeLines a b = ImportLine (importModule a) (importAlias a) (importTypes a `Set.union` importTypes b)  unlessM :: Monad m => m Bool -> m () -> m () unlessM mbool action = mbool >>= flip unless action

@@ -55,12 +55,12 @@ --   In order to get the type information we use a dummy variable of type 'Proxy' (YourType). mkSumType :: forall t. (Generic t, Typeable t, GDataConstructor (Rep t))           => Proxy t -> SumType 'Haskell-mkSumType p = SumType (mkTypeInfo p) constructors (Encode : Decode : Generic : maybeToList (nootype constructors))+mkSumType p = SumType (mkTypeInfo p) constructors (Encode : Decode : EncodeJson : DecodeJson : Generic : maybeToList (nootype constructors))   where     constructors = gToConstructors (from (undefined :: t))  -- | Purescript typeclass instances that can be generated for your Haskell types.-data Instance = Encode | Decode | Generic | Newtype | Eq | Ord deriving (Eq, Show)+data Instance = Encode | EncodeJson | Decode | DecodeJson | Generic | Newtype | Eq | Ord deriving (Eq, Show)  -- | The Purescript typeclass `Newtype` might be derivable if the original -- Haskell type was a simple type wrapper.@@ -85,7 +85,6 @@                   , _sigValues      :: !(Either [TypeInfo lang] [RecordEntry lang])                   } deriving (Show, Eq) - data RecordEntry (lang :: Language) =   RecordEntry { _recLabel :: !Text -- ^ e.g. `runState` for `State`               , _recValue :: !(TypeInfo lang)@@ -117,7 +116,6 @@ instance (GRecordEntry a, GRecordEntry b) => GRecordEntry (a :*: b) where   gToRecordEntries (_ :: (a :*: b) f) = gToRecordEntries (undefined :: a f)                                      ++ gToRecordEntries (undefined :: b f)-  instance GRecordEntry U1 where   gToRecordEntries _ = []

@@ -4,6 +4,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings     #-} {-# LANGUAGE RankNTypes            #-}+{-# LANGUAGE TypeApplications      #-} {-# LANGUAGE TypeSynonymInstances  #-}  module Main where@@ -11,6 +12,7 @@ import           Data.Monoid                               ((<>)) import           Data.Proxy import qualified Data.Text                                 as T+import           Data.Word                                 (Word, Word64) import           Language.PureScript.Bridge import           Language.PureScript.Bridge.TypeParameters import           Language.PureScript.Bridge.CodeGenSwitches@@ -25,8 +27,7 @@  allTests :: Spec allTests = do-  describe "buildBridge for purescript 0.12" $ do-    let settings = purs_0_11_settings+  describe "buildBridge for purescript 0.14" $ do     it "tests with Int" $       let bst = buildBridge defaultBridge (mkTypeInfo (Proxy :: Proxy Int))           ti  = TypeInfo { _typePackage    = ""@@ -51,12 +52,12 @@                                       ]                   }                 ]-                [Eq, Ord, Encode, Decode, Generic]+                [Eq, Ord, Encode, Decode, EncodeJson, DecodeJson, Generic]        in bst `shouldBe` st     it "tests generation of for custom type Foo" $      let prox = Proxy :: Proxy Foo          recType = bridgeSumType (buildBridge defaultBridge) (order prox $ mkSumType prox)-         recTypeText = sumTypeToText settings recType+         recTypeText = sumTypeToText defaultSettings recType          txt = T.stripEnd $                T.unlines [ "data Foo ="                          , "    Foo"@@ -65,7 +66,11 @@                          , ""                          , "derive instance eqFoo :: Eq Foo"                          , "derive instance ordFoo :: Ord Foo"-                         , "derive instance genericFoo :: Generic Foo"+                         , "instance encodeJsonFoo :: EncodeJson Foo where"+                         , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+                         , "instance decodeJsonFoo :: DecodeJson Foo where"+                         , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+                         , "derive instance genericFoo :: Generic Foo _"                          , ""                          , "--------------------------------------------------------------------------------"                          , "_Foo :: Prism' Foo Unit"@@ -92,18 +97,23 @@     it "tests the generation of a whole (dummy) module" $       let advanced = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy (Bar A B M1 C)))           modules = sumTypeToModule advanced Map.empty-          m = head . map (moduleToText settings) . Map.elems $ modules+          m = head . map (moduleToText defaultSettings) . Map.elems $ modules           txt = T.unlines [ "-- File auto generated by purescript-bridge! --"                           , "module TestData where"                           , ""+                          , "import Data.Argonaut.Aeson.Decode.Generic (genericDecodeAeson)"+                          , "import Data.Argonaut.Aeson.Encode.Generic (genericEncodeAeson)"+                          , "import Data.Argonaut.Aeson.Options as Argonaut"+                          , "import Data.Argonaut.Decode.Class (class DecodeJson, class DecodeJsonField, decodeJson)"+                          , "import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)"                           , "import Data.Either (Either)"-                          , "import Data.Generic (class Generic)"+                          , "import Data.Generic.Rep (class Generic)"                           , "import Data.Lens (Iso', Lens', Prism', lens, prism')"                           , "import Data.Lens.Iso.Newtype (_Newtype)"                           , "import Data.Lens.Record (prop)"                           , "import Data.Maybe (Maybe, Maybe(..))"                           , "import Data.Newtype (class Newtype)"-                          , "import Data.Symbol (SProxy(SProxy))"+                          , "import Type.Proxy (Proxy(Proxy))"                           , ""                           , "import Prelude"                           , ""@@ -115,7 +125,11 @@                           , "      myMonadicResult :: m b"                           , "    }"                           , ""-                          , "derive instance genericBar :: (Generic a, Generic b, Generic (m b)) => Generic (Bar a b m c)"+                          , "instance encodeJsonBar :: (Generic a ra, EncodeJson a, Generic b rb, EncodeJson b, Generic (m b) rmb, EncodeJson (m b)) => EncodeJson (Bar a b m c) where"+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+                          , "instance decodeJsonBar :: (Generic a ra, DecodeJson a, DecodeJsonField a, Generic b rb, DecodeJson b, DecodeJsonField b, Generic (m b) rmb, DecodeJson (m b), DecodeJsonField (m b)) => DecodeJson (Bar a b m c) where"+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+                          , "derive instance genericBar :: (Generic a ra, Generic b rb, Generic (m b) rmb) => Generic (Bar a b m c) _"                           , ""                           , "--------------------------------------------------------------------------------"                           , "_Bar1 :: forall a b m c. Prism' (Bar a b m c) (Maybe a)"@@ -202,16 +216,16 @@           recTypeOptics = recordOptics recType           txt = T.unlines [                             "a :: forall a b. Lens' (SingleRecord a b) a"-                          , "a = _Newtype <<< prop (SProxy :: SProxy \"_a\")"+                          , "a = _Newtype <<< prop (Proxy :: Proxy \"_a\")"                           , ""                           , "b :: forall a b. Lens' (SingleRecord a b) b"-                          , "b = _Newtype <<< prop (SProxy :: SProxy \"_b\")"+                          , "b = _Newtype <<< prop (Proxy :: Proxy \"_b\")"                           , ""                           ]       in (barOptics <> recTypeOptics) `shouldBe` txt     it "tests generation of newtypes for record data type" $       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy (SingleRecord A B)))-          recTypeText = sumTypeToText settings recType+          recTypeText = sumTypeToText defaultSettings recType           txt = T.stripEnd $                 T.unlines [ "newtype SingleRecord a b ="                           , "    SingleRecord {"@@ -220,7 +234,11 @@                           , "    , c :: String"                           , "    }"                           , ""-                          , "derive instance genericSingleRecord :: (Generic a, Generic b) => Generic (SingleRecord a b)"+                          , "instance encodeJsonSingleRecord :: (Generic a ra, EncodeJson a, Generic b rb, EncodeJson b) => EncodeJson (SingleRecord a b) where"+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+                          , "instance decodeJsonSingleRecord :: (Generic a ra, DecodeJson a, DecodeJsonField a, Generic b rb, DecodeJson b, DecodeJsonField b) => DecodeJson (SingleRecord a b) where"+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+                          , "derive instance genericSingleRecord :: (Generic a ra, Generic b rb) => Generic (SingleRecord a b) _"                           , "derive instance newtypeSingleRecord :: Newtype (SingleRecord a b) _"                           , ""                           , "--------------------------------------------------------------------------------"@@ -228,22 +246,26 @@                           , "_SingleRecord = _Newtype"                           ,""                           , "a :: forall a b. Lens' (SingleRecord a b) a"-                          , "a = _Newtype <<< prop (SProxy :: SProxy \"_a\")"+                          , "a = _Newtype <<< prop (Proxy :: Proxy \"_a\")"                           , ""                           , "b :: forall a b. Lens' (SingleRecord a b) b"-                          , "b = _Newtype <<< prop (SProxy :: SProxy \"_b\")"+                          , "b = _Newtype <<< prop (Proxy :: Proxy \"_b\")"                           , ""                           , "--------------------------------------------------------------------------------"                           ]       in recTypeText `shouldBe` txt     it "tests generation of newtypes for haskell newtype" $       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy SomeNewtype))-          recTypeText = sumTypeToText settings recType+          recTypeText = sumTypeToText defaultSettings recType           txt = T.stripEnd $                 T.unlines [ "newtype SomeNewtype ="                           , "    SomeNewtype Int"                           , ""-                          , "derive instance genericSomeNewtype :: Generic SomeNewtype"+                          , "instance encodeJsonSomeNewtype :: EncodeJson SomeNewtype where"+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+                          , "instance decodeJsonSomeNewtype :: DecodeJson SomeNewtype where"+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+                          , "derive instance genericSomeNewtype :: Generic SomeNewtype _"                           , "derive instance newtypeSomeNewtype :: Newtype SomeNewtype _"                           , ""                           , "--------------------------------------------------------------------------------"@@ -254,12 +276,16 @@       in recTypeText `shouldBe` txt     it "tests generation of newtypes for haskell data type with one argument" $       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy SingleValueConstr))-          recTypeText = sumTypeToText settings recType+          recTypeText = sumTypeToText defaultSettings recType           txt = T.stripEnd $                 T.unlines [ "newtype SingleValueConstr ="                           , "    SingleValueConstr Int"                           , ""-                          , "derive instance genericSingleValueConstr :: Generic SingleValueConstr"+                          , "instance encodeJsonSingleValueConstr :: EncodeJson SingleValueConstr where"+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+                          , "instance decodeJsonSingleValueConstr :: DecodeJson SingleValueConstr where"+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+                          , "derive instance genericSingleValueConstr :: Generic SingleValueConstr _"                           , "derive instance newtypeSingleValueConstr :: Newtype SingleValueConstr _"                           , ""                           , "--------------------------------------------------------------------------------"@@ -270,12 +296,16 @@       in recTypeText `shouldBe` txt     it "tests generation for haskell data type with one constructor, two arguments" $       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy SingleProduct))-          recTypeText = sumTypeToText settings recType+          recTypeText = sumTypeToText defaultSettings recType           txt = T.stripEnd $                 T.unlines [ "data SingleProduct ="                           , "    SingleProduct String Int"                           , ""-                          , "derive instance genericSingleProduct :: Generic SingleProduct"+                          , "instance encodeJsonSingleProduct :: EncodeJson SingleProduct where"+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"+                          , "instance decodeJsonSingleProduct :: DecodeJson SingleProduct where"+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"+                          , "derive instance genericSingleProduct :: Generic SingleProduct _"                           , ""                           , "--------------------------------------------------------------------------------"                           , "_SingleProduct :: Prism' SingleProduct { a :: String, b :: Int }"@@ -291,8 +321,8 @@           recTypeOptics = recordOptics recType       in recTypeOptics `shouldBe` "" -- No record optics for multi-constructors -  describe "buildBridge without lens-code-gen for purescript 0.11" $ do-    let settings = getSettings (noLenses <> useGen)+  describe "buildBridge without lens-code-gen and argonaut-codecs" $ do+    let settings = getSettings (noLenses <> useGen <> noArgonautCodecs)     it "tests generation of for custom type Foo" $       let proxy = Proxy :: Proxy Foo           recType = bridgeSumType (buildBridge defaultBridge) (order proxy $ mkSumType proxy)@@ -378,8 +408,8 @@       in recTypeText `shouldBe` txt  -  describe "buildBridge without lens-code-gen and generics-rep" $ do-    let settings = getSettings (noLenses <> useGenRep)+  describe "buildBridge without lens-code-gen, generics-rep, and argonaut-codecs" $ do+    let settings = getSettings (noLenses <> useGenRep <> noArgonautCodecs)     it "tests generation of for custom type Foo" $       let proxy = Proxy :: Proxy Foo           recType = bridgeSumType (buildBridge defaultBridge) (order proxy $ mkSumType proxy)@@ -464,3 +494,42 @@                           ]       in recTypeText `shouldBe` txt  +  describe "tests bridging Haskells Data.Word to PureScripts Data.Word from purescript-word" $ do+    describe "moduleToText" $+      it "should contain the right import and datatype" $ do+        let settings = getSettings (noLenses <> useGen <> noArgonautCodecs)+            createModuleText :: SumType 'Haskell -> T.Text+            createModuleText sumType =+              let bridge = buildBridge defaultBridge+                  modules = sumTypeToModule (bridgeSumType bridge sumType) Map.empty+               in head . map (moduleToText settings) . Map.elems $ modules+            expectedText =+              T.unlines+                [ "-- File auto generated by purescript-bridge! --"+                , "module TestData where"+                , ""+                , "import Data.Generic (class Generic)"+                , "import Data.Maybe (Maybe(..))"+                , "import Data.Newtype (class Newtype)"+                , "import Data.Word (Word64)"+                , ""+                , "import Prelude"+                , ""+                , "newtype Simple Word64 ="+                , "    Simple Word64"+                , ""+                , "derive instance genericSimple :: Generic Word64 => Generic (Simple Word64)"+                , "derive instance newtypeSimple :: Newtype (Simple Word64) _"+                , ""+                ]+        createModuleText (mkSumType (Proxy @(Simple Word64))) `shouldBe`  expectedText+    describe "buildBridge" $+      it "should create the correct type information for Word" $ do+        let bst = buildBridge defaultBridge (mkTypeInfo (Proxy @Word))+            ti  = TypeInfo { _typePackage    = "purescript-word"+                         , _typeModule     = "Data.Word"+                         , _typeName       = "Word"+                         , _typeParameters = []}+         in bst `shouldBe` ti++

@@ -30,6 +30,8 @@    haskType ^== mkTypeInfo (Proxy :: Proxy String)    return psString +data Simple a = Simple a deriving (Generic, Typeable, Show)+ data Foo = Foo          | Bar Int          | FooBar Int Text