{-# LANGUAGE OverloadedStrings, FlexibleInstances, TypeApplications #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

module HsDev.Database.SQLite.Instances (
	JSON(..)
	) where

import Control.Lens ((^.), (^?), _Just)
import Data.Aeson as A hiding (Error)
import Data.Maybe
import Data.Foldable
import Data.Time.Clock.POSIX
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.ByteString.Lazy as L
import Database.SQLite.Simple
import Database.SQLite.Simple.ToField
import Database.SQLite.Simple.FromField
import Language.Haskell.Extension
import qualified Language.Haskell.Names as N
import qualified Language.Haskell.Exts as H
import Text.Format

import System.Directory.Paths
import HsDev.Display
import HsDev.Symbols.Name
import HsDev.Symbols.Location
import HsDev.Symbols.Types
import HsDev.Tools.Ghc.Types
import HsDev.Tools.Types
import HsDev.Util

instance ToField Value where
	toField :: Value -> SQLData
toField = ByteString -> SQLData
SQLBlob (ByteString -> SQLData)
-> (Value -> ByteString) -> Value -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
L.toStrict (ByteString -> ByteString)
-> (Value -> ByteString) -> Value -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> ByteString
forall a. ToJSON a => a -> ByteString
encode

instance FromField Value where
	fromField :: FieldParser Value
fromField Field
fld = case Field -> SQLData
fieldData Field
fld of
		SQLText Text
s -> (String -> Ok Value)
-> (Value -> Ok Value) -> Either String Value -> Ok Value
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> Ok Value
forall (m :: * -> *) a. MonadFail m => String -> m a
fail Value -> Ok Value
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String Value -> Ok Value)
-> (Text -> Either String Value) -> Text -> Ok Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either String Value
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (ByteString -> Either String Value)
-> (Text -> ByteString) -> Text -> Either String Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
L.fromStrict (ByteString -> ByteString)
-> (Text -> ByteString) -> Text -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
T.encodeUtf8 (Text -> Ok Value) -> Text -> Ok Value
forall a b. (a -> b) -> a -> b
$ Text
s
		SQLBlob ByteString
s -> (String -> Ok Value)
-> (Value -> Ok Value) -> Either String Value -> Ok Value
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> Ok Value
forall (m :: * -> *) a. MonadFail m => String -> m a
fail Value -> Ok Value
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String Value -> Ok Value)
-> (ByteString -> Either String Value) -> ByteString -> Ok Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either String Value
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (ByteString -> Either String Value)
-> (ByteString -> ByteString) -> ByteString -> Either String Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
L.fromStrict (ByteString -> Ok Value) -> ByteString -> Ok Value
forall a b. (a -> b) -> a -> b
$ ByteString
s
		SQLData
_ -> String -> Ok Value
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid json field type"

newtype JSON a = JSON { JSON a -> a
getJSON :: a }
	deriving (JSON a -> JSON a -> Bool
(JSON a -> JSON a -> Bool)
-> (JSON a -> JSON a -> Bool) -> Eq (JSON a)
forall a. Eq a => JSON a -> JSON a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JSON a -> JSON a -> Bool
$c/= :: forall a. Eq a => JSON a -> JSON a -> Bool
== :: JSON a -> JSON a -> Bool
$c== :: forall a. Eq a => JSON a -> JSON a -> Bool
Eq, Eq (JSON a)
Eq (JSON a)
-> (JSON a -> JSON a -> Ordering)
-> (JSON a -> JSON a -> Bool)
-> (JSON a -> JSON a -> Bool)
-> (JSON a -> JSON a -> Bool)
-> (JSON a -> JSON a -> Bool)
-> (JSON a -> JSON a -> JSON a)
-> (JSON a -> JSON a -> JSON a)
-> Ord (JSON a)
JSON a -> JSON a -> Bool
JSON a -> JSON a -> Ordering
JSON a -> JSON a -> JSON a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (JSON a)
forall a. Ord a => JSON a -> JSON a -> Bool
forall a. Ord a => JSON a -> JSON a -> Ordering
forall a. Ord a => JSON a -> JSON a -> JSON a
min :: JSON a -> JSON a -> JSON a
$cmin :: forall a. Ord a => JSON a -> JSON a -> JSON a
max :: JSON a -> JSON a -> JSON a
$cmax :: forall a. Ord a => JSON a -> JSON a -> JSON a
>= :: JSON a -> JSON a -> Bool
$c>= :: forall a. Ord a => JSON a -> JSON a -> Bool
> :: JSON a -> JSON a -> Bool
$c> :: forall a. Ord a => JSON a -> JSON a -> Bool
<= :: JSON a -> JSON a -> Bool
$c<= :: forall a. Ord a => JSON a -> JSON a -> Bool
< :: JSON a -> JSON a -> Bool
$c< :: forall a. Ord a => JSON a -> JSON a -> Bool
compare :: JSON a -> JSON a -> Ordering
$ccompare :: forall a. Ord a => JSON a -> JSON a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (JSON a)
Ord, ReadPrec [JSON a]
ReadPrec (JSON a)
Int -> ReadS (JSON a)
ReadS [JSON a]
(Int -> ReadS (JSON a))
-> ReadS [JSON a]
-> ReadPrec (JSON a)
-> ReadPrec [JSON a]
-> Read (JSON a)
forall a. Read a => ReadPrec [JSON a]
forall a. Read a => ReadPrec (JSON a)
forall a. Read a => Int -> ReadS (JSON a)
forall a. Read a => ReadS [JSON a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [JSON a]
$creadListPrec :: forall a. Read a => ReadPrec [JSON a]
readPrec :: ReadPrec (JSON a)
$creadPrec :: forall a. Read a => ReadPrec (JSON a)
readList :: ReadS [JSON a]
$creadList :: forall a. Read a => ReadS [JSON a]
readsPrec :: Int -> ReadS (JSON a)
$creadsPrec :: forall a. Read a => Int -> ReadS (JSON a)
Read, Int -> JSON a -> ShowS
[JSON a] -> ShowS
JSON a -> String
(Int -> JSON a -> ShowS)
-> (JSON a -> String) -> ([JSON a] -> ShowS) -> Show (JSON a)
forall a. Show a => Int -> JSON a -> ShowS
forall a. Show a => [JSON a] -> ShowS
forall a. Show a => JSON a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JSON a] -> ShowS
$cshowList :: forall a. Show a => [JSON a] -> ShowS
show :: JSON a -> String
$cshow :: forall a. Show a => JSON a -> String
showsPrec :: Int -> JSON a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> JSON a -> ShowS
Show)

instance ToJSON a => ToField (JSON a) where
	toField :: JSON a -> SQLData
toField = ByteString -> SQLData
SQLBlob (ByteString -> SQLData)
-> (JSON a -> ByteString) -> JSON a -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
L.toStrict (ByteString -> ByteString)
-> (JSON a -> ByteString) -> JSON a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ByteString
forall a. ToJSON a => a -> ByteString
encode (a -> ByteString) -> (JSON a -> a) -> JSON a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSON a -> a
forall a. JSON a -> a
getJSON

instance FromJSON a => FromField (JSON a) where
	fromField :: FieldParser (JSON a)
fromField Field
fld = case Field -> SQLData
fieldData Field
fld of
		SQLText Text
s -> (String -> Ok (JSON a))
-> (a -> Ok (JSON a)) -> Either String a -> Ok (JSON a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> Ok (JSON a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (JSON a -> Ok (JSON a)
forall (m :: * -> *) a. Monad m => a -> m a
return (JSON a -> Ok (JSON a)) -> (a -> JSON a) -> a -> Ok (JSON a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> JSON a
forall a. a -> JSON a
JSON) (Either String a -> Ok (JSON a))
-> (Text -> Either String a) -> Text -> Ok (JSON a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either String a
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (ByteString -> Either String a)
-> (Text -> ByteString) -> Text -> Either String a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
L.fromStrict (ByteString -> ByteString)
-> (Text -> ByteString) -> Text -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
T.encodeUtf8 (Text -> Ok (JSON a)) -> Text -> Ok (JSON a)
forall a b. (a -> b) -> a -> b
$ Text
s
		SQLBlob ByteString
s -> (String -> Ok (JSON a))
-> (a -> Ok (JSON a)) -> Either String a -> Ok (JSON a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> Ok (JSON a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (JSON a -> Ok (JSON a)
forall (m :: * -> *) a. Monad m => a -> m a
return (JSON a -> Ok (JSON a)) -> (a -> JSON a) -> a -> Ok (JSON a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> JSON a
forall a. a -> JSON a
JSON) (Either String a -> Ok (JSON a))
-> (ByteString -> Either String a) -> ByteString -> Ok (JSON a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either String a
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (ByteString -> Either String a)
-> (ByteString -> ByteString) -> ByteString -> Either String a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
L.fromStrict (ByteString -> Ok (JSON a)) -> ByteString -> Ok (JSON a)
forall a b. (a -> b) -> a -> b
$ ByteString
s
		SQLData
_ -> String -> Ok (JSON a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid json field type"

instance FromRow Position where
	fromRow :: RowParser Position
fromRow = Int -> Int -> Position
Position (Int -> Int -> Position)
-> RowParser Int -> RowParser (Int -> Position)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Int
forall a. FromField a => RowParser a
field RowParser (Int -> Position) -> RowParser Int -> RowParser Position
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Int
forall a. FromField a => RowParser a
field

instance ToRow Position where
	toRow :: Position -> [SQLData]
toRow (Position Int
l Int
c) = [Int -> SQLData
forall a. ToField a => a -> SQLData
toField Int
l, Int -> SQLData
forall a. ToField a => a -> SQLData
toField Int
c]

instance FromRow Region where
	fromRow :: RowParser Region
fromRow = Position -> Position -> Region
Region (Position -> Position -> Region)
-> RowParser Position -> RowParser (Position -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Position
forall a. FromRow a => RowParser a
fromRow RowParser (Position -> Region)
-> RowParser Position -> RowParser Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Position
forall a. FromRow a => RowParser a
fromRow

instance ToRow Region where
	toRow :: Region -> [SQLData]
toRow (Region Position
f Position
t) = Position -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow Position
f [SQLData] -> [SQLData] -> [SQLData]
forall a. [a] -> [a] -> [a]
++ Position -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow Position
t

instance FromRow ModulePackage where
	fromRow :: RowParser ModulePackage
fromRow = Text -> Text -> ModulePackage
ModulePackage (Text -> Text -> ModulePackage)
-> RowParser Text -> RowParser (Text -> ModulePackage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Text -> ModulePackage)
-> RowParser Text -> RowParser ModulePackage
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
T.empty (Maybe Text -> Text) -> RowParser (Maybe Text) -> RowParser Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field)

instance ToRow ModulePackage where
	toRow :: ModulePackage -> [SQLData]
toRow (ModulePackage Text
name Text
ver) = [Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
name, Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
ver]

instance FromRow ModuleLocation where
	fromRow :: RowParser ModuleLocation
fromRow = do
		Maybe Text
file <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe String
cabal <- RowParser (Maybe String)
forall a. FromField a => RowParser a
field
		Maybe Value
dirs <- RowParser (Maybe Value)
forall a. FromField a => RowParser a
field
		Maybe Text
pname <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Text
pver <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Text
iname <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Bool
iexposed <- RowParser (Maybe Bool)
forall a. FromField a => RowParser a
field
		Maybe Text
other <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field

		RowParser ModuleLocation
-> (ModuleLocation -> RowParser ModuleLocation)
-> Maybe ModuleLocation
-> RowParser ModuleLocation
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser ModuleLocation
forall (m :: * -> *) a. MonadPlus m => m a
mzero ModuleLocation -> RowParser ModuleLocation
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ModuleLocation -> RowParser ModuleLocation)
-> Maybe ModuleLocation -> RowParser ModuleLocation
forall a b. (a -> b) -> a -> b
$ [Maybe ModuleLocation] -> Maybe ModuleLocation
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum [
			Text -> Maybe Project -> ModuleLocation
FileModule (Text -> Maybe Project -> ModuleLocation)
-> Maybe Text -> Maybe (Maybe Project -> ModuleLocation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
file Maybe (Maybe Project -> ModuleLocation)
-> Maybe (Maybe Project) -> Maybe ModuleLocation
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Project -> Maybe (Maybe Project)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Project
project (String -> Project) -> Maybe String -> Maybe Project
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe String
cabal),
			[Text] -> ModulePackage -> Text -> Bool -> ModuleLocation
InstalledModule ([Text] -> ModulePackage -> Text -> Bool -> ModuleLocation)
-> Maybe [Text]
-> Maybe (ModulePackage -> Text -> Bool -> ModuleLocation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Text]
-> (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Text] -> Maybe [Text]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []) Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' Maybe Value
dirs Maybe (ModulePackage -> Text -> Bool -> ModuleLocation)
-> Maybe ModulePackage -> Maybe (Text -> Bool -> ModuleLocation)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Text -> Text -> ModulePackage
ModulePackage (Text -> Text -> ModulePackage)
-> Maybe Text -> Maybe (Text -> ModulePackage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
pname Maybe (Text -> ModulePackage) -> Maybe Text -> Maybe ModulePackage
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text
pver) Maybe (Text -> Bool -> ModuleLocation)
-> Maybe Text -> Maybe (Bool -> ModuleLocation)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text
iname Maybe (Bool -> ModuleLocation)
-> Maybe Bool -> Maybe ModuleLocation
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Bool
iexposed,
			Text -> ModuleLocation
OtherLocation (Text -> ModuleLocation) -> Maybe Text -> Maybe ModuleLocation
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
other,
			ModuleLocation -> Maybe ModuleLocation
forall (f :: * -> *) a. Applicative f => a -> f a
pure ModuleLocation
NoLocation]

instance ToRow ModuleLocation where
	toRow :: ModuleLocation -> [SQLData]
toRow ModuleLocation
mloc = [
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) ModuleLocation Text
Traversal' ModuleLocation Text
moduleFile,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (Maybe Project -> Const (First Text) (Maybe Project))
-> ModuleLocation -> Const (First Text) ModuleLocation
Traversal' ModuleLocation (Maybe Project)
moduleProject ((Maybe Project -> Const (First Text) (Maybe Project))
 -> ModuleLocation -> Const (First Text) ModuleLocation)
-> ((Text -> Const (First Text) Text)
    -> Maybe Project -> Const (First Text) (Maybe Project))
-> Getting (First Text) ModuleLocation Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Project -> Const (First Text) Project)
-> Maybe Project -> Const (First Text) (Maybe Project)
forall a b. Prism (Maybe a) (Maybe b) a b
_Just ((Project -> Const (First Text) Project)
 -> Maybe Project -> Const (First Text) (Maybe Project))
-> ((Text -> Const (First Text) Text)
    -> Project -> Const (First Text) Project)
-> (Text -> Const (First Text) Text)
-> Maybe Project
-> Const (First Text) (Maybe Project)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> Project -> Const (First Text) Project
Lens' Project Text
projectCabal,
		Maybe Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Value -> SQLData) -> Maybe Value -> SQLData
forall a b. (a -> b) -> a -> b
$ ([Text] -> Value) -> Maybe [Text] -> Maybe Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON (Maybe [Text] -> Maybe Value) -> Maybe [Text] -> Maybe Value
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First [Text]) ModuleLocation [Text] -> Maybe [Text]
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First [Text]) ModuleLocation [Text]
Traversal' ModuleLocation [Text]
moduleInstallDirs,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (ModulePackage -> Const (First Text) ModulePackage)
-> ModuleLocation -> Const (First Text) ModuleLocation
Traversal' ModuleLocation ModulePackage
modulePackage ((ModulePackage -> Const (First Text) ModulePackage)
 -> ModuleLocation -> Const (First Text) ModuleLocation)
-> ((Text -> Const (First Text) Text)
    -> ModulePackage -> Const (First Text) ModulePackage)
-> Getting (First Text) ModuleLocation Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> ModulePackage -> Const (First Text) ModulePackage
Lens' ModulePackage Text
packageName,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (ModulePackage -> Const (First Text) ModulePackage)
-> ModuleLocation -> Const (First Text) ModuleLocation
Traversal' ModuleLocation ModulePackage
modulePackage ((ModulePackage -> Const (First Text) ModulePackage)
 -> ModuleLocation -> Const (First Text) ModuleLocation)
-> ((Text -> Const (First Text) Text)
    -> ModulePackage -> Const (First Text) ModulePackage)
-> Getting (First Text) ModuleLocation Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> ModulePackage -> Const (First Text) ModulePackage
Lens' ModulePackage Text
packageVersion,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) ModuleLocation Text
Traversal' ModuleLocation Text
installedModuleName,
		Maybe Bool -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Bool -> SQLData) -> Maybe Bool -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Bool) ModuleLocation Bool -> Maybe Bool
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Bool) ModuleLocation Bool
Traversal' ModuleLocation Bool
installedModuleExposed,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) ModuleLocation Text
Traversal' ModuleLocation Text
otherLocationName]

instance FromRow ModuleId where
	fromRow :: RowParser ModuleId
fromRow = Text -> ModuleLocation -> ModuleId
ModuleId (Text -> ModuleLocation -> ModuleId)
-> RowParser Text -> RowParser (ModuleLocation -> ModuleId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (ModuleLocation -> ModuleId)
-> RowParser ModuleLocation -> RowParser ModuleId
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser ModuleLocation
forall a. FromRow a => RowParser a
fromRow

instance ToRow ModuleId where
	toRow :: ModuleId -> [SQLData]
toRow ModuleId
mid = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (ModuleId
mid ModuleId -> Getting Text ModuleId Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text ModuleId Text
Lens' ModuleId Text
moduleName) SQLData -> [SQLData] -> [SQLData]
forall a. a -> [a] -> [a]
: ModuleLocation -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow (ModuleId
mid ModuleId
-> Getting ModuleLocation ModuleId ModuleLocation -> ModuleLocation
forall s a. s -> Getting a s a -> a
^. Getting ModuleLocation ModuleId ModuleLocation
Lens' ModuleId ModuleLocation
moduleLocation)

instance FromRow Import where
	fromRow :: RowParser Import
fromRow = Position -> Text -> Bool -> Maybe Text -> Import
Import (Position -> Text -> Bool -> Maybe Text -> Import)
-> RowParser Position
-> RowParser (Text -> Bool -> Maybe Text -> Import)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Position
forall a. FromRow a => RowParser a
fromRow RowParser (Text -> Bool -> Maybe Text -> Import)
-> RowParser Text -> RowParser (Bool -> Maybe Text -> Import)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Bool -> Maybe Text -> Import)
-> RowParser Bool -> RowParser (Maybe Text -> Import)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Bool
forall a. FromField a => RowParser a
field RowParser (Maybe Text -> Import)
-> RowParser (Maybe Text) -> RowParser Import
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field

instance ToRow Import where
	toRow :: Import -> [SQLData]
toRow (Import Position
p Text
n Bool
q Maybe Text
a) = Position -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow Position
p [SQLData] -> [SQLData] -> [SQLData]
forall a. [a] -> [a] -> [a]
++ [Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
n, Bool -> SQLData
forall a. ToField a => a -> SQLData
toField Bool
q, Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe Text
a]

instance FromRow SymbolId where
	fromRow :: RowParser SymbolId
fromRow = Text -> ModuleId -> SymbolId
SymbolId (Text -> ModuleId -> SymbolId)
-> RowParser Text -> RowParser (ModuleId -> SymbolId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (ModuleId -> SymbolId)
-> RowParser ModuleId -> RowParser SymbolId
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser ModuleId
forall a. FromRow a => RowParser a
fromRow

instance ToRow SymbolId where
	toRow :: SymbolId -> [SQLData]
toRow (SymbolId Text
nm ModuleId
mid) = Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
nm SQLData -> [SQLData] -> [SQLData]
forall a. a -> [a] -> [a]
: ModuleId -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow ModuleId
mid

instance FromRow SymbolInfo where
	fromRow :: RowParser SymbolInfo
fromRow = do
		String
what <- FromField String => RowParser String
forall a. FromField a => RowParser a
field @String
		Maybe Text
ty <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Text
parent <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Value
ctors <- RowParser (Maybe Value)
forall a. FromField a => RowParser a
field
		Maybe Value
args <- RowParser (Maybe Value)
forall a. FromField a => RowParser a
field
		Maybe Value
ctx <- RowParser (Maybe Value)
forall a. FromField a => RowParser a
field
		Maybe Text
assoc <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Text
patTy <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		Maybe Text
patCtor <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		RowParser SymbolInfo
-> (SymbolInfo -> RowParser SymbolInfo)
-> Maybe SymbolInfo
-> RowParser SymbolInfo
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser SymbolInfo
forall (m :: * -> *) a. MonadPlus m => m a
mzero SymbolInfo -> RowParser SymbolInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe SymbolInfo -> RowParser SymbolInfo)
-> Maybe SymbolInfo -> RowParser SymbolInfo
forall a b. (a -> b) -> a -> b
$ case String
what of
			String
"function" -> SymbolInfo -> Maybe SymbolInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (SymbolInfo -> Maybe SymbolInfo) -> SymbolInfo -> Maybe SymbolInfo
forall a b. (a -> b) -> a -> b
$ Maybe Text -> SymbolInfo
Function Maybe Text
ty
			String
"method" -> Maybe Text -> Text -> SymbolInfo
Method (Maybe Text -> Text -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe (Text -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
ty Maybe (Text -> SymbolInfo) -> Maybe Text -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text
parent
			String
"selector" -> Maybe Text -> Text -> [Text] -> SymbolInfo
Selector (Maybe Text -> Text -> [Text] -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe (Text -> [Text] -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
ty Maybe (Text -> [Text] -> SymbolInfo)
-> Maybe Text -> Maybe ([Text] -> SymbolInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text
parent Maybe ([Text] -> SymbolInfo) -> Maybe [Text] -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctors)
			String
"ctor" -> [Text] -> Text -> SymbolInfo
Constructor ([Text] -> Text -> SymbolInfo)
-> Maybe [Text] -> Maybe (Text -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe (Text -> SymbolInfo) -> Maybe Text -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text
parent
			String
"type" -> [Text] -> [Text] -> SymbolInfo
Type ([Text] -> [Text] -> SymbolInfo)
-> Maybe [Text] -> Maybe ([Text] -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe ([Text] -> SymbolInfo) -> Maybe [Text] -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctx)
			String
"newtype" -> [Text] -> [Text] -> SymbolInfo
NewType ([Text] -> [Text] -> SymbolInfo)
-> Maybe [Text] -> Maybe ([Text] -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe ([Text] -> SymbolInfo) -> Maybe [Text] -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctx)
			String
"data" -> [Text] -> [Text] -> SymbolInfo
Data ([Text] -> [Text] -> SymbolInfo)
-> Maybe [Text] -> Maybe ([Text] -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe ([Text] -> SymbolInfo) -> Maybe [Text] -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctx)
			String
"class" -> [Text] -> [Text] -> SymbolInfo
Class ([Text] -> [Text] -> SymbolInfo)
-> Maybe [Text] -> Maybe ([Text] -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe ([Text] -> SymbolInfo) -> Maybe [Text] -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctx)
			String
"type-family" -> [Text] -> [Text] -> Maybe Text -> SymbolInfo
TypeFam ([Text] -> [Text] -> Maybe Text -> SymbolInfo)
-> Maybe [Text] -> Maybe ([Text] -> Maybe Text -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe ([Text] -> Maybe Text -> SymbolInfo)
-> Maybe [Text] -> Maybe (Maybe Text -> SymbolInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctx) Maybe (Maybe Text -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
assoc
			String
"data-family" -> [Text] -> [Text] -> Maybe Text -> SymbolInfo
DataFam ([Text] -> [Text] -> Maybe Text -> SymbolInfo)
-> Maybe [Text] -> Maybe ([Text] -> Maybe Text -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe ([Text] -> Maybe Text -> SymbolInfo)
-> Maybe [Text] -> Maybe (Maybe Text -> SymbolInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
ctx) Maybe (Maybe Text -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
assoc
			String
"pat-ctor" -> [Text] -> Maybe Text -> SymbolInfo
PatConstructor ([Text] -> Maybe Text -> SymbolInfo)
-> Maybe [Text] -> Maybe (Maybe Text -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' (Value -> Maybe [Text]) -> Maybe Value -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Value
args) Maybe (Maybe Text -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
patTy
			String
"pat-selector" -> Maybe Text -> Maybe Text -> Text -> SymbolInfo
PatSelector (Maybe Text -> Maybe Text -> Text -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe (Maybe Text -> Text -> SymbolInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
ty Maybe (Maybe Text -> Text -> SymbolInfo)
-> Maybe (Maybe Text) -> Maybe (Text -> SymbolInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> Maybe (Maybe Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
patTy Maybe (Text -> SymbolInfo) -> Maybe Text -> Maybe SymbolInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text
patCtor
			String
_ -> Maybe SymbolInfo
forall a. Maybe a
Nothing

instance ToRow SymbolInfo where
	toRow :: SymbolInfo -> [SQLData]
toRow SymbolInfo
si = [
		String -> SQLData
forall a. ToField a => a -> SQLData
toField (String -> SQLData) -> String -> SQLData
forall a b. (a -> b) -> a -> b
$ SymbolInfo -> String
symbolInfoType SymbolInfo
si,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo -> Getting (First Text) SymbolInfo Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (Maybe Text -> Const (First Text) (Maybe Text))
-> SymbolInfo -> Const (First Text) SymbolInfo
Traversal' SymbolInfo (Maybe Text)
functionType ((Maybe Text -> Const (First Text) (Maybe Text))
 -> SymbolInfo -> Const (First Text) SymbolInfo)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) SymbolInfo Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a b. Prism (Maybe a) (Maybe b) a b
_Just,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ [Maybe Text] -> Maybe Text
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum [SymbolInfo
si SymbolInfo -> Getting (First Text) SymbolInfo Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) SymbolInfo Text
Traversal' SymbolInfo Text
parentClass, SymbolInfo
si SymbolInfo -> Getting (First Text) SymbolInfo Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) SymbolInfo Text
Traversal' SymbolInfo Text
parentType],
		Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Value -> SQLData) -> Value -> SQLData
forall a b. (a -> b) -> a -> b
$ Maybe [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON (Maybe [Text] -> Value) -> Maybe [Text] -> Value
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo
-> Getting (First [Text]) SymbolInfo [Text] -> Maybe [Text]
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First [Text]) SymbolInfo [Text]
Traversal' SymbolInfo [Text]
selectorConstructors,
		Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Value -> SQLData) -> Value -> SQLData
forall a b. (a -> b) -> a -> b
$ Maybe [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON (Maybe [Text] -> Value) -> Maybe [Text] -> Value
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo
-> Getting (First [Text]) SymbolInfo [Text] -> Maybe [Text]
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First [Text]) SymbolInfo [Text]
Traversal' SymbolInfo [Text]
typeArgs,
		Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Value -> SQLData) -> Value -> SQLData
forall a b. (a -> b) -> a -> b
$ Maybe [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON (Maybe [Text] -> Value) -> Maybe [Text] -> Value
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo
-> Getting (First [Text]) SymbolInfo [Text] -> Maybe [Text]
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First [Text]) SymbolInfo [Text]
Traversal' SymbolInfo [Text]
typeContext,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo -> Getting (First Text) SymbolInfo Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (Maybe Text -> Const (First Text) (Maybe Text))
-> SymbolInfo -> Const (First Text) SymbolInfo
Traversal' SymbolInfo (Maybe Text)
familyAssociate ((Maybe Text -> Const (First Text) (Maybe Text))
 -> SymbolInfo -> Const (First Text) SymbolInfo)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) SymbolInfo Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a b. Prism (Maybe a) (Maybe b) a b
_Just,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo -> Getting (First Text) SymbolInfo Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (Maybe Text -> Const (First Text) (Maybe Text))
-> SymbolInfo -> Const (First Text) SymbolInfo
Traversal' SymbolInfo (Maybe Text)
patternType ((Maybe Text -> Const (First Text) (Maybe Text))
 -> SymbolInfo -> Const (First Text) SymbolInfo)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) SymbolInfo Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a b. Prism (Maybe a) (Maybe b) a b
_Just,
		Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ SymbolInfo
si SymbolInfo -> Getting (First Text) SymbolInfo Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) SymbolInfo Text
Traversal' SymbolInfo Text
patternConstructor]

instance FromRow Symbol where
	fromRow :: RowParser Symbol
fromRow = SymbolId -> Maybe Text -> Maybe Position -> SymbolInfo -> Symbol
Symbol (SymbolId -> Maybe Text -> Maybe Position -> SymbolInfo -> Symbol)
-> RowParser SymbolId
-> RowParser (Maybe Text -> Maybe Position -> SymbolInfo -> Symbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser SymbolId
forall a. FromRow a => RowParser a
fromRow RowParser (Maybe Text -> Maybe Position -> SymbolInfo -> Symbol)
-> RowParser (Maybe Text)
-> RowParser (Maybe Position -> SymbolInfo -> Symbol)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field RowParser (Maybe Position -> SymbolInfo -> Symbol)
-> RowParser (Maybe Position) -> RowParser (SymbolInfo -> Symbol)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Position)
pos RowParser (SymbolInfo -> Symbol)
-> RowParser SymbolInfo -> RowParser Symbol
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser SymbolInfo
forall a. FromRow a => RowParser a
fromRow where
		pos :: RowParser (Maybe Position)
pos = do
			Maybe Int
line <- RowParser (Maybe Int)
forall a. FromField a => RowParser a
field
			Maybe Int
column <- RowParser (Maybe Int)
forall a. FromField a => RowParser a
field
			Maybe Position -> RowParser (Maybe Position)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Position -> RowParser (Maybe Position))
-> Maybe Position -> RowParser (Maybe Position)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Position
Position (Int -> Int -> Position) -> Maybe Int -> Maybe (Int -> Position)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int
line Maybe (Int -> Position) -> Maybe Int -> Maybe Position
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Int
column

instance ToRow Symbol where
	toRow :: Symbol -> [SQLData]
toRow Symbol
sym = [[SQLData]] -> [SQLData]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [
		SymbolId -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow (Symbol
sym Symbol -> Getting SymbolId Symbol SymbolId -> SymbolId
forall s a. s -> Getting a s a -> a
^. Getting SymbolId Symbol SymbolId
Lens' Symbol SymbolId
symbolId),
		[Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ Symbol
sym Symbol -> Getting (Maybe Text) Symbol (Maybe Text) -> Maybe Text
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Text) Symbol (Maybe Text)
Lens' Symbol (Maybe Text)
symbolDocs],
		[SQLData] -> (Position -> [SQLData]) -> Maybe Position -> [SQLData]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [SQLData
SQLNull, SQLData
SQLNull] Position -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow (Symbol
sym Symbol
-> Getting (Maybe Position) Symbol (Maybe Position)
-> Maybe Position
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Position) Symbol (Maybe Position)
Lens' Symbol (Maybe Position)
symbolPosition),
		SymbolInfo -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow (Symbol
sym Symbol -> Getting SymbolInfo Symbol SymbolInfo -> SymbolInfo
forall s a. s -> Getting a s a -> a
^. Getting SymbolInfo Symbol SymbolInfo
Lens' Symbol SymbolInfo
symbolInfo)]

instance FromRow a => FromRow (Scoped a) where
	fromRow :: RowParser (Scoped a)
fromRow = (Maybe Text -> a -> Scoped a) -> a -> Maybe Text -> Scoped a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Maybe Text -> a -> Scoped a
forall a. Maybe Text -> a -> Scoped a
Scoped (a -> Maybe Text -> Scoped a)
-> RowParser a -> RowParser (Maybe Text -> Scoped a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser a
forall a. FromRow a => RowParser a
fromRow RowParser (Maybe Text -> Scoped a)
-> RowParser (Maybe Text) -> RowParser (Scoped a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field

instance ToRow a => ToRow (Scoped a) where
	toRow :: Scoped a -> [SQLData]
toRow (Scoped Maybe Text
q a
s) = a -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow a
s [SQLData] -> [SQLData] -> [SQLData]
forall a. [a] -> [a] -> [a]
++ [Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe Text
q]

instance ToField BuildTool where
	toField :: BuildTool -> SQLData
toField BuildTool
CabalTool = String -> SQLData
forall a. ToField a => a -> SQLData
toField @String String
"cabal"
	toField BuildTool
StackTool = String -> SQLData
forall a. ToField a => a -> SQLData
toField @String String
"stack"

instance FromField BuildTool where
	fromField :: FieldParser BuildTool
fromField = FromField String => FieldParser String
forall a. FromField a => FieldParser a
fromField @String FieldParser String
-> (String -> Ok BuildTool) -> FieldParser BuildTool
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> Ok BuildTool
forall a (m :: * -> *).
(Eq a, IsString a, MonadPlus m) =>
a -> m BuildTool
fromStr where
		fromStr :: a -> m BuildTool
fromStr a
"cabal" = BuildTool -> m BuildTool
forall (m :: * -> *) a. Monad m => a -> m a
return BuildTool
CabalTool
		fromStr a
"stack" = BuildTool -> m BuildTool
forall (m :: * -> *) a. Monad m => a -> m a
return BuildTool
StackTool
		fromStr a
_ = m BuildTool
forall (m :: * -> *) a. MonadPlus m => m a
mzero

instance ToRow Sandbox where
	toRow :: Sandbox -> [SQLData]
toRow (Sandbox BuildTool
t Text
p) = [BuildTool -> SQLData
forall a. ToField a => a -> SQLData
toField BuildTool
t, Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
p]

instance FromRow Sandbox where
	fromRow :: RowParser Sandbox
fromRow = BuildTool -> Text -> Sandbox
Sandbox (BuildTool -> Text -> Sandbox)
-> RowParser BuildTool -> RowParser (Text -> Sandbox)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser BuildTool
forall a. FromField a => RowParser a
field RowParser (Text -> Sandbox) -> RowParser Text -> RowParser Sandbox
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Text
forall a. FromField a => RowParser a
field

instance ToRow Project where
	toRow :: Project -> [SQLData]
toRow (Project Text
name Text
_ Text
cabal Maybe ProjectDescription
pdesc BuildTool
t Maybe PackageDbStack
dbs) = [Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
name, Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
cabal, Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ Maybe ProjectDescription
pdesc Maybe ProjectDescription
-> Getting (First Text) (Maybe ProjectDescription) Text
-> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? (ProjectDescription -> Const (First Text) ProjectDescription)
-> Maybe ProjectDescription
-> Const (First Text) (Maybe ProjectDescription)
forall a b. Prism (Maybe a) (Maybe b) a b
_Just ((ProjectDescription -> Const (First Text) ProjectDescription)
 -> Maybe ProjectDescription
 -> Const (First Text) (Maybe ProjectDescription))
-> ((Text -> Const (First Text) Text)
    -> ProjectDescription -> Const (First Text) ProjectDescription)
-> Getting (First Text) (Maybe ProjectDescription) Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const (First Text) Text)
-> ProjectDescription -> Const (First Text) ProjectDescription
Lens' ProjectDescription Text
projectVersion, BuildTool -> SQLData
forall a. ToField a => a -> SQLData
toField BuildTool
t, Maybe PackageDbStack -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe PackageDbStack
dbs]

instance FromRow Project where
	fromRow :: RowParser Project
fromRow = do
		Text
name <- RowParser Text
forall a. FromField a => RowParser a
field
		Text
cabal <- RowParser Text
forall a. FromField a => RowParser a
field
		Maybe Text
ver <- RowParser (Maybe Text)
forall a. FromField a => RowParser a
field
		BuildTool
tool <- RowParser BuildTool
forall a. FromField a => RowParser a
field
		Maybe PackageDbStack
dbs <- RowParser (Maybe PackageDbStack)
forall a. FromField a => RowParser a
field
		Project -> RowParser Project
forall (m :: * -> *) a. Monad m => a -> m a
return (Project -> RowParser Project) -> Project -> RowParser Project
forall a b. (a -> b) -> a -> b
$ Text
-> Text
-> Text
-> Maybe ProjectDescription
-> BuildTool
-> Maybe PackageDbStack
-> Project
Project Text
name (Text -> Text
takeDir Text
cabal) Text
cabal ((Text -> ProjectDescription)
-> Maybe Text -> Maybe ProjectDescription
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Text
v -> Text
-> Maybe Library -> [Executable] -> [Test] -> ProjectDescription
ProjectDescription Text
v Maybe Library
forall a. Maybe a
Nothing [] []) Maybe Text
ver) BuildTool
tool Maybe PackageDbStack
dbs

instance FromRow Library where
	fromRow :: RowParser Library
fromRow = do
		[[Text]]
mods <- RowParser Value
forall a. FromField a => RowParser a
field RowParser Value
-> (Value -> RowParser [[Text]]) -> RowParser [[Text]]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RowParser [[Text]]
-> ([[Text]] -> RowParser [[Text]])
-> Maybe [[Text]]
-> RowParser [[Text]]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [[Text]]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [[Text]] -> RowParser [[Text]]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [[Text]] -> RowParser [[Text]])
-> (Value -> Maybe [[Text]]) -> Value -> RowParser [[Text]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [[Text]]
forall a. FromJSON a => Value -> Maybe a
fromJSON'
		Info
binfo <- RowParser Info
forall a. FromRow a => RowParser a
fromRow
		Library -> RowParser Library
forall (m :: * -> *) a. Monad m => a -> m a
return (Library -> RowParser Library) -> Library -> RowParser Library
forall a b. (a -> b) -> a -> b
$ [[Text]] -> Info -> Library
Library [[Text]]
mods Info
binfo

instance FromRow Executable where
	fromRow :: RowParser Executable
fromRow = Text -> Text -> Info -> Executable
Executable (Text -> Text -> Info -> Executable)
-> RowParser Text -> RowParser (Text -> Info -> Executable)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Text -> Info -> Executable)
-> RowParser Text -> RowParser (Info -> Executable)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Info -> Executable)
-> RowParser Info -> RowParser Executable
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Info
forall a. FromRow a => RowParser a
fromRow

instance FromRow Test where
	fromRow :: RowParser Test
fromRow = Text -> Bool -> Maybe Text -> Info -> Test
Test (Text -> Bool -> Maybe Text -> Info -> Test)
-> RowParser Text -> RowParser (Bool -> Maybe Text -> Info -> Test)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Bool -> Maybe Text -> Info -> Test)
-> RowParser Bool -> RowParser (Maybe Text -> Info -> Test)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Bool
forall a. FromField a => RowParser a
field RowParser (Maybe Text -> Info -> Test)
-> RowParser (Maybe Text) -> RowParser (Info -> Test)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field RowParser (Info -> Test) -> RowParser Info -> RowParser Test
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Info
forall a. FromRow a => RowParser a
fromRow

instance FromRow Info where
	fromRow :: RowParser Info
fromRow = [Text]
-> Maybe Language
-> [Extension]
-> [Text]
-> [Text]
-> [[Text]]
-> Info
Info ([Text]
 -> Maybe Language
 -> [Extension]
 -> [Text]
 -> [Text]
 -> [[Text]]
 -> Info)
-> RowParser [Text]
-> RowParser
     (Maybe Language
      -> [Extension] -> [Text] -> [Text] -> [[Text]] -> Info)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
		(RowParser Value
forall a. FromField a => RowParser a
field RowParser Value -> (Value -> RowParser [Text]) -> RowParser [Text]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RowParser [Text]
-> ([Text] -> RowParser [Text]) -> Maybe [Text] -> RowParser [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [Text]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [Text] -> RowParser [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Text] -> RowParser [Text])
-> (Value -> Maybe [Text]) -> Value -> RowParser [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON') RowParser
  (Maybe Language
   -> [Extension] -> [Text] -> [Text] -> [[Text]] -> Info)
-> RowParser (Maybe Language)
-> RowParser ([Extension] -> [Text] -> [Text] -> [[Text]] -> Info)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
		RowParser (Maybe Language)
forall a. FromField a => RowParser a
field RowParser ([Extension] -> [Text] -> [Text] -> [[Text]] -> Info)
-> RowParser [Extension]
-> RowParser ([Text] -> [Text] -> [[Text]] -> Info)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
		(RowParser Value
forall a. FromField a => RowParser a
field RowParser Value
-> (Value -> RowParser [Extension]) -> RowParser [Extension]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RowParser [Extension]
-> ([Extension] -> RowParser [Extension])
-> Maybe [Extension]
-> RowParser [Extension]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [Extension]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [Extension] -> RowParser [Extension]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Extension] -> RowParser [Extension])
-> (Value -> Maybe [Extension]) -> Value -> RowParser [Extension]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [Extension]
forall a. FromJSON a => Value -> Maybe a
fromJSON') RowParser ([Text] -> [Text] -> [[Text]] -> Info)
-> RowParser [Text] -> RowParser ([Text] -> [[Text]] -> Info)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
		(RowParser Value
forall a. FromField a => RowParser a
field RowParser Value -> (Value -> RowParser [Text]) -> RowParser [Text]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RowParser [Text]
-> ([Text] -> RowParser [Text]) -> Maybe [Text] -> RowParser [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [Text]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [Text] -> RowParser [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Text] -> RowParser [Text])
-> (Value -> Maybe [Text]) -> Value -> RowParser [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON') RowParser ([Text] -> [[Text]] -> Info)
-> RowParser [Text] -> RowParser ([[Text]] -> Info)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
		(RowParser Value
forall a. FromField a => RowParser a
field RowParser Value -> (Value -> RowParser [Text]) -> RowParser [Text]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RowParser [Text]
-> ([Text] -> RowParser [Text]) -> Maybe [Text] -> RowParser [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [Text]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [Text] -> RowParser [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Text] -> RowParser [Text])
-> (Value -> Maybe [Text]) -> Value -> RowParser [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON') RowParser ([[Text]] -> Info)
-> RowParser [[Text]] -> RowParser Info
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
		(RowParser Value
forall a. FromField a => RowParser a
field RowParser Value
-> (Value -> RowParser [[Text]]) -> RowParser [[Text]]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RowParser [[Text]]
-> ([[Text]] -> RowParser [[Text]])
-> Maybe [[Text]]
-> RowParser [[Text]]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [[Text]]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [[Text]] -> RowParser [[Text]]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [[Text]] -> RowParser [[Text]])
-> (Value -> Maybe [[Text]]) -> Value -> RowParser [[Text]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [[Text]]
forall a. FromJSON a => Value -> Maybe a
fromJSON')

instance FromField Language where
	fromField :: FieldParser Language
fromField Field
fld = case Field -> SQLData
fieldData Field
fld of
		SQLText Text
txt -> String -> String -> Ok Language
forall (m :: * -> *) a.
(MonadFail m, Monad m, Parsec a) =>
String -> String -> m a
parseDT String
"Language" (Text -> String
T.unpack Text
txt)
		SQLData
_ -> Ok Language
forall (m :: * -> *) a. MonadPlus m => m a
mzero

instance ToField PackageDb where
	toField :: PackageDb -> SQLData
toField PackageDb
GlobalDb = String -> SQLData
forall a. ToField a => a -> SQLData
toField (String
"global-db" :: String)
	toField PackageDb
UserDb = String -> SQLData
forall a. ToField a => a -> SQLData
toField (String
"user-db" :: String)
	toField (PackageDb Text
p) = String -> SQLData
forall a. ToField a => a -> SQLData
toField (String
"package-db:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
p)

instance FromField PackageDb where
	fromField :: FieldParser PackageDb
fromField Field
fld = do
		Text
s <- FieldParser Text
forall a. FromField a => FieldParser a
fromField Field
fld
		case Text
s of
			Text
"global-db" -> PackageDb -> Ok PackageDb
forall (m :: * -> *) a. Monad m => a -> m a
return PackageDb
GlobalDb
			Text
"user-db" -> PackageDb -> Ok PackageDb
forall (m :: * -> *) a. Monad m => a -> m a
return PackageDb
UserDb
			Text
_ -> case Text -> Text -> Maybe Text
T.stripPrefix Text
"package-db:" Text
s of
				Just Text
p' -> PackageDb -> Ok PackageDb
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageDb -> Ok PackageDb) -> PackageDb -> Ok PackageDb
forall a b. (a -> b) -> a -> b
$ Text -> PackageDb
PackageDb Text
p'
				Maybe Text
Nothing -> Ok PackageDb
forall (m :: * -> *) a. MonadPlus m => m a
mzero

instance ToField PackageDbStack where
	toField :: PackageDbStack -> SQLData
toField = Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Value -> SQLData)
-> (PackageDbStack -> Value) -> PackageDbStack -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PackageDb] -> Value
forall a. ToJSON a => a -> Value
toJSON ([PackageDb] -> Value)
-> (PackageDbStack -> [PackageDb]) -> PackageDbStack -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDbStack -> [PackageDb]
packageDbs

instance FromField PackageDbStack where
	fromField :: FieldParser PackageDbStack
fromField = FieldParser Value
forall a. FromField a => FieldParser a
fromField FieldParser Value
-> (Value -> Ok PackageDbStack) -> FieldParser PackageDbStack
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ok PackageDbStack
-> ([PackageDb] -> Ok PackageDbStack)
-> Maybe [PackageDb]
-> Ok PackageDbStack
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Ok PackageDbStack
forall (m :: * -> *) a. MonadPlus m => m a
mzero (PackageDbStack -> Ok PackageDbStack
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageDbStack -> Ok PackageDbStack)
-> ([PackageDb] -> PackageDbStack)
-> [PackageDb]
-> Ok PackageDbStack
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PackageDb] -> PackageDbStack
mkPackageDbStack) (Maybe [PackageDb] -> Ok PackageDbStack)
-> (Value -> Maybe [PackageDb]) -> Value -> Ok PackageDbStack
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe [PackageDb]
forall a. FromJSON a => Value -> Maybe a
fromJSON'

instance FromRow SymbolUsage where
	fromRow :: RowParser SymbolUsage
fromRow = Symbol -> Maybe Text -> ModuleId -> Region -> SymbolUsage
SymbolUsage (Symbol -> Maybe Text -> ModuleId -> Region -> SymbolUsage)
-> RowParser Symbol
-> RowParser (Maybe Text -> ModuleId -> Region -> SymbolUsage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Symbol
forall a. FromRow a => RowParser a
fromRow RowParser (Maybe Text -> ModuleId -> Region -> SymbolUsage)
-> RowParser (Maybe Text)
-> RowParser (ModuleId -> Region -> SymbolUsage)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field RowParser (ModuleId -> Region -> SymbolUsage)
-> RowParser ModuleId -> RowParser (Region -> SymbolUsage)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser ModuleId
forall a. FromRow a => RowParser a
fromRow RowParser (Region -> SymbolUsage)
-> RowParser Region -> RowParser SymbolUsage
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Region
forall a. FromRow a => RowParser a
fromRow

instance FromField POSIXTime where
	fromField :: FieldParser POSIXTime
fromField = (Double -> POSIXTime) -> Ok Double -> Ok POSIXTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Rational -> POSIXTime
forall a. Fractional a => Rational -> a
fromRational (Rational -> POSIXTime)
-> (Double -> Rational) -> Double -> POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Real Double => Double -> Rational
forall a. Real a => a -> Rational
toRational @Double) (Ok Double -> Ok POSIXTime)
-> (Field -> Ok Double) -> FieldParser POSIXTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Field -> Ok Double
forall a. FromField a => FieldParser a
fromField

instance ToField POSIXTime where
	toField :: POSIXTime -> SQLData
toField = Double -> SQLData
forall a. ToField a => a -> SQLData
toField (Double -> SQLData)
-> (POSIXTime -> Double) -> POSIXTime -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fractional Double => Rational -> Double
forall a. Fractional a => Rational -> a
fromRational @Double (Rational -> Double)
-> (POSIXTime -> Rational) -> POSIXTime -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> Rational
forall a. Real a => a -> Rational
toRational

instance FromRow Inspection where
	fromRow :: RowParser Inspection
fromRow = do
		Maybe POSIXTime
tm <- RowParser (Maybe POSIXTime)
forall a. FromField a => RowParser a
field
		Maybe Value
opts <- RowParser (Maybe Value)
forall a. FromField a => RowParser a
field
		case (Maybe POSIXTime
tm, Maybe Value
opts) of
			(Maybe POSIXTime
Nothing, Maybe Value
Nothing) -> Inspection -> RowParser Inspection
forall (m :: * -> *) a. Monad m => a -> m a
return Inspection
InspectionNone
			(Maybe POSIXTime
_, Just Value
opts') -> POSIXTime -> [Text] -> Inspection
InspectionAt (POSIXTime -> Maybe POSIXTime -> POSIXTime
forall a. a -> Maybe a -> a
fromMaybe POSIXTime
0 Maybe POSIXTime
tm) ([Text] -> Inspection) -> RowParser [Text] -> RowParser Inspection
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
				RowParser [Text]
-> ([Text] -> RowParser [Text]) -> Maybe [Text] -> RowParser [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser [Text]
forall (m :: * -> *) a. MonadPlus m => m a
mzero [Text] -> RowParser [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return (Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON' Value
opts')
			(Just POSIXTime
_, Maybe Value
Nothing) -> RowParser Inspection
forall (m :: * -> *) a. MonadPlus m => m a
mzero

instance ToRow Inspection where
	toRow :: Inspection -> [SQLData]
toRow Inspection
InspectionNone = [SQLData
SQLNull, SQLData
SQLNull]
	toRow (InspectionAt POSIXTime
tm [Text]
opts) = [
		if POSIXTime
tm POSIXTime -> POSIXTime -> Bool
forall a. Eq a => a -> a -> Bool
== POSIXTime
0 then SQLData
SQLNull else POSIXTime -> SQLData
forall a. ToField a => a -> SQLData
toField POSIXTime
tm,
		Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Value -> SQLData) -> Value -> SQLData
forall a b. (a -> b) -> a -> b
$ [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON [Text]
opts]

instance FromRow TypedExpr where
	fromRow :: RowParser TypedExpr
fromRow = Maybe Text -> Text -> TypedExpr
TypedExpr (Maybe Text -> Text -> TypedExpr)
-> RowParser (Maybe Text) -> RowParser (Text -> TypedExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field RowParser (Text -> TypedExpr)
-> RowParser Text -> RowParser TypedExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Text
forall a. FromField a => RowParser a
field

instance ToRow TypedExpr where
	toRow :: TypedExpr -> [SQLData]
toRow (TypedExpr Maybe Text
e Text
t) = [Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe Text
e, Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
t]

instance FromField (H.Name ()) where
	fromField :: FieldParser (Name ())
fromField = (Text -> Name ()) -> Ok Text -> Ok (Name ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Name ()
toName_ (Ok Text -> Ok (Name ()))
-> FieldParser Text -> FieldParser (Name ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldParser Text
forall a. FromField a => FieldParser a
fromField

instance ToField (H.Name ()) where
	toField :: Name () -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData) -> (Name () -> Text) -> Name () -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name () -> Text
fromName_

instance FromField (H.ModuleName ()) where
	fromField :: FieldParser (ModuleName ())
fromField = (Text -> ModuleName ()) -> Ok Text -> Ok (ModuleName ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> ModuleName ()
toModuleName_ (Ok Text -> Ok (ModuleName ()))
-> FieldParser Text -> FieldParser (ModuleName ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldParser Text
forall a. FromField a => FieldParser a
fromField

instance ToField (H.ModuleName ()) where
	toField :: ModuleName () -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData)
-> (ModuleName () -> Text) -> ModuleName () -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleName () -> Text
fromModuleName_

instance FromRow N.Symbol where
	fromRow :: RowParser Symbol
fromRow = do
		Text
what <- FromField Text => RowParser Text
forall a. FromField a => RowParser a
field @T.Text
		Text
mname <- RowParser Text
forall a. FromField a => RowParser a
field
		Text
name <- RowParser Text
forall a. FromField a => RowParser a
field
		Maybe (Name ())
parent <- RowParser (Maybe (Name ()))
forall a. FromField a => RowParser a
field
		Maybe [Name ()]
ctors <- do
			Maybe Value
ctorsJson <- RowParser (Maybe Value)
forall a. FromField a => RowParser a
field
			Maybe [Name ()] -> RowParser (Maybe [Name ()])
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Name ()] -> RowParser (Maybe [Name ()]))
-> Maybe [Name ()] -> RowParser (Maybe [Name ()])
forall a b. (a -> b) -> a -> b
$ ([Text] -> [Name ()]) -> Maybe [Text] -> Maybe [Name ()]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Text -> Name ()) -> [Text] -> [Name ()]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Name ()
toName_) (Maybe Value
ctorsJson Maybe Value -> (Value -> Maybe [Text]) -> Maybe [Text]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Maybe [Text]
forall a. FromJSON a => Value -> Maybe a
fromJSON')
		Maybe (Name ())
assoc <- RowParser (Maybe (Name ()))
forall a. FromField a => RowParser a
field
		Maybe (Name ())
patType <- RowParser (Maybe (Name ()))
forall a. FromField a => RowParser a
field
		Maybe (Name ())
patCtor <- RowParser (Maybe (Name ()))
forall a. FromField a => RowParser a
field
		let
			m :: ModuleName ()
m = Text -> ModuleName ()
toModuleName_ Text
mname
			n :: Name ()
n = Text -> Name ()
toName_ Text
name
		RowParser Symbol
-> (Symbol -> RowParser Symbol) -> Maybe Symbol -> RowParser Symbol
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RowParser Symbol
forall (m :: * -> *) a. MonadPlus m => m a
mzero Symbol -> RowParser Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Symbol -> RowParser Symbol)
-> Maybe Symbol -> RowParser Symbol
forall a b. (a -> b) -> a -> b
$ case Text
what of
			Text
"function" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Symbol
N.Value ModuleName ()
m Name ()
n
			Text
"method" -> ModuleName () -> Name () -> Name () -> Symbol
N.Method ModuleName ()
m Name ()
n (Name () -> Symbol) -> Maybe (Name ()) -> Maybe Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Name ())
parent
			Text
"selector" -> ModuleName () -> Name () -> Name () -> [Name ()] -> Symbol
N.Selector ModuleName ()
m Name ()
n (Name () -> [Name ()] -> Symbol)
-> Maybe (Name ()) -> Maybe ([Name ()] -> Symbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Name ())
parent Maybe ([Name ()] -> Symbol) -> Maybe [Name ()] -> Maybe Symbol
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe [Name ()]
ctors
			Text
"ctor" -> ModuleName () -> Name () -> Name () -> Symbol
N.Constructor ModuleName ()
m Name ()
n (Name () -> Symbol) -> Maybe (Name ()) -> Maybe Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Name ())
parent
			Text
"type" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Symbol
N.Type ModuleName ()
m Name ()
n
			Text
"newtype" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Symbol
N.NewType ModuleName ()
m Name ()
n
			Text
"data" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Symbol
N.Data ModuleName ()
m Name ()
n
			Text
"class" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Symbol
N.Class ModuleName ()
m Name ()
n
			Text
"type-family" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Maybe (Name ()) -> Symbol
N.TypeFam ModuleName ()
m Name ()
n Maybe (Name ())
assoc
			Text
"data-family" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Maybe (Name ()) -> Symbol
N.DataFam ModuleName ()
m Name ()
n Maybe (Name ())
assoc
			Text
"pat-ctor" -> Symbol -> Maybe Symbol
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol -> Maybe Symbol) -> Symbol -> Maybe Symbol
forall a b. (a -> b) -> a -> b
$ ModuleName () -> Name () -> Maybe (Name ()) -> Symbol
N.PatternConstructor ModuleName ()
m Name ()
n Maybe (Name ())
patType
			Text
"pat-selector" -> ModuleName () -> Name () -> Maybe (Name ()) -> Name () -> Symbol
N.PatternSelector ModuleName ()
m Name ()
n Maybe (Name ())
patType (Name () -> Symbol) -> Maybe (Name ()) -> Maybe Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Name ())
patCtor
			Text
_ -> Maybe Symbol
forall a. Maybe a
Nothing

instance ToRow N.Symbol where
	toRow :: Symbol -> [SQLData]
toRow = Int -> [SQLData] -> [SQLData]
padNulls Int
8 ([SQLData] -> [SQLData])
-> (Symbol -> [SQLData]) -> Symbol -> [SQLData]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> [SQLData]
toRow' where
		toRow' :: Symbol -> [SQLData]
toRow' (N.Value ModuleName ()
m Name ()
n) = Text -> [SQLData] -> [SQLData]
mk Text
"function" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n]
		toRow' (N.Method ModuleName ()
m Name ()
n Name ()
p) = Text -> [SQLData] -> [SQLData]
mk Text
"method" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
p]
		toRow' (N.Selector ModuleName ()
m Name ()
n Name ()
p [Name ()]
cs) = Text -> [SQLData] -> [SQLData]
mk Text
"selector" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
p, Value -> SQLData
forall a. ToField a => a -> SQLData
toField (Value -> SQLData) -> Value -> SQLData
forall a b. (a -> b) -> a -> b
$ [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON ((Name () -> Text) -> [Name ()] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Name () -> Text
fromName_ [Name ()]
cs)]
		toRow' (N.Constructor ModuleName ()
m Name ()
n Name ()
p) = Text -> [SQLData] -> [SQLData]
mk Text
"ctor" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
p]
		toRow' (N.Type ModuleName ()
m Name ()
n) = Text -> [SQLData] -> [SQLData]
mk Text
"type" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n]
		toRow' (N.NewType ModuleName ()
m Name ()
n) = Text -> [SQLData] -> [SQLData]
mk Text
"newtype" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n]
		toRow' (N.Data ModuleName ()
m Name ()
n) = Text -> [SQLData] -> [SQLData]
mk Text
"data" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n]
		toRow' (N.Class ModuleName ()
m Name ()
n) = Text -> [SQLData] -> [SQLData]
mk Text
"class" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n]
		toRow' (N.TypeFam ModuleName ()
m Name ()
n Maybe (Name ())
assoc) = Text -> [SQLData] -> [SQLData]
mk Text
"type-family" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, SQLData
SQLNull, SQLData
SQLNull, Maybe (Name ()) -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe (Name ())
assoc]
		toRow' (N.DataFam ModuleName ()
m Name ()
n Maybe (Name ())
assoc) = Text -> [SQLData] -> [SQLData]
mk Text
"data-family" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, SQLData
SQLNull, SQLData
SQLNull, Maybe (Name ()) -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe (Name ())
assoc]
		toRow' (N.PatternConstructor ModuleName ()
m Name ()
n Maybe (Name ())
pty) = Text -> [SQLData] -> [SQLData]
mk Text
"pat-ctor" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, SQLData
SQLNull, SQLData
SQLNull, SQLData
SQLNull, Maybe (Name ()) -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe (Name ())
pty]
		toRow' (N.PatternSelector ModuleName ()
m Name ()
n Maybe (Name ())
pty Name ()
pctor) = Text -> [SQLData] -> [SQLData]
mk Text
"pat-selector" [ModuleName () -> SQLData
forall a. ToField a => a -> SQLData
toField ModuleName ()
m, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
n, SQLData
SQLNull, SQLData
SQLNull, SQLData
SQLNull, Maybe (Name ()) -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe (Name ())
pty, Name () -> SQLData
forall a. ToField a => a -> SQLData
toField Name ()
pctor]

		mk :: T.Text -> [SQLData] -> [SQLData]
		mk :: Text -> [SQLData] -> [SQLData]
mk Text
what = (Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
what SQLData -> [SQLData] -> [SQLData]
forall a. a -> [a] -> [a]
:)
		padNulls :: Int -> [SQLData] -> [SQLData]
padNulls Int
n [SQLData]
fs = [SQLData]
fs [SQLData] -> [SQLData] -> [SQLData]
forall a. [a] -> [a] -> [a]
++ Int -> SQLData -> [SQLData]
forall a. Int -> a -> [a]
replicate (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- [SQLData] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SQLData]
fs) SQLData
SQLNull

instance FromField Severity where
	fromField :: FieldParser Severity
fromField Field
fld = do
		String
s <- FieldParser String
forall a. FromField a => FieldParser a
fromField @String Field
fld
		[Ok Severity] -> Ok Severity
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum [
			Bool -> Ok ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"error") Ok () -> Ok Severity -> Ok Severity
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Severity -> Ok Severity
forall (m :: * -> *) a. Monad m => a -> m a
return Severity
Error,
			Bool -> Ok ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"warning") Ok () -> Ok Severity -> Ok Severity
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Severity -> Ok Severity
forall (m :: * -> *) a. Monad m => a -> m a
return Severity
Warning,
			Bool -> Ok ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"hint") Ok () -> Ok Severity -> Ok Severity
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Severity -> Ok Severity
forall (m :: * -> *) a. Monad m => a -> m a
return Severity
Hint]

instance ToField Severity where
	toField :: Severity -> SQLData
toField Severity
Error = String -> SQLData
forall a. ToField a => a -> SQLData
toField @String String
"error"
	toField Severity
Warning = String -> SQLData
forall a. ToField a => a -> SQLData
toField @String String
"warning"
	toField Severity
Hint = String -> SQLData
forall a. ToField a => a -> SQLData
toField @String String
"hint"

instance FromRow OutputMessage where
	fromRow :: RowParser OutputMessage
fromRow = Text -> Maybe Text -> OutputMessage
OutputMessage (Text -> Maybe Text -> OutputMessage)
-> RowParser Text -> RowParser (Maybe Text -> OutputMessage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Maybe Text -> OutputMessage)
-> RowParser (Maybe Text) -> RowParser OutputMessage
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Text)
forall a. FromField a => RowParser a
field

instance ToRow OutputMessage where
	toRow :: OutputMessage -> [SQLData]
toRow (OutputMessage Text
msg Maybe Text
suggest) = [Text -> SQLData
forall a. ToField a => a -> SQLData
toField Text
msg, Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe Text
suggest]

instance FromRow a => FromRow (Note a) where
	fromRow :: RowParser (Note a)
fromRow = ModuleLocation -> Region -> Maybe Severity -> a -> Note a
forall a. ModuleLocation -> Region -> Maybe Severity -> a -> Note a
Note (ModuleLocation -> Region -> Maybe Severity -> a -> Note a)
-> RowParser ModuleLocation
-> RowParser (Region -> Maybe Severity -> a -> Note a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> Maybe Project -> ModuleLocation
FileModule (Text -> Maybe Project -> ModuleLocation)
-> RowParser Text -> RowParser (Maybe Project -> ModuleLocation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RowParser Text
forall a. FromField a => RowParser a
field RowParser (Maybe Project -> ModuleLocation)
-> RowParser (Maybe Project) -> RowParser ModuleLocation
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Project -> RowParser (Maybe Project)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Project
forall a. Maybe a
Nothing) RowParser (Region -> Maybe Severity -> a -> Note a)
-> RowParser Region -> RowParser (Maybe Severity -> a -> Note a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser Region
forall a. FromRow a => RowParser a
fromRow RowParser (Maybe Severity -> a -> Note a)
-> RowParser (Maybe Severity) -> RowParser (a -> Note a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser (Maybe Severity)
forall a. FromField a => RowParser a
field RowParser (a -> Note a) -> RowParser a -> RowParser (Note a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> RowParser a
forall a. FromRow a => RowParser a
fromRow

instance ToRow a => ToRow (Note a) where
	toRow :: Note a -> [SQLData]
toRow (Note ModuleLocation
mloc Region
rgn Maybe Severity
sev a
n) = [[SQLData]] -> [SQLData]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [
		[Maybe Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Maybe Text -> SQLData) -> Maybe Text -> SQLData
forall a b. (a -> b) -> a -> b
$ ModuleLocation
mloc ModuleLocation
-> Getting (First Text) ModuleLocation Text -> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
^? Getting (First Text) ModuleLocation Text
Traversal' ModuleLocation Text
moduleFile],
		Region -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow Region
rgn,
		[Maybe Severity -> SQLData
forall a. ToField a => a -> SQLData
toField Maybe Severity
sev],
		a -> [SQLData]
forall a. ToRow a => a -> [SQLData]
toRow a
n]