Protolude completion in library and executable (#697)

src/PostgREST/Parsers.hs

@@ -1,13 +1,9 @@
-module PostgREST.Parsers
--- ( parseGetRequest
--- )
-where
+module PostgREST.Parsers where
 
-import           Prelude
-import           Control.Applicative           hiding ((<$>))
-import           Data.Monoid
-import           Data.String.Conversions       (cs)
-import           Data.Text                     (Text, intercalate)
+import           Protolude                     hiding (try, intercalate)
+import           Control.Monad                ((>>))
+import           Data.Text                     (intercalate)
+import           Data.List                     (init, last)
 import           Data.Tree
 import           PostgREST.QueryBuilder        (operators)
 import           PostgREST.Types
@@ -29,31 +25,31 @@ pRequestSelect rootNodeName = do
             newForest =
               foldr treeEntry (Node (Select [] [fn] [] Nothing allRange, (fn, Nothing, alias)) []) fldForest:rForest
 
-pRequestFilter :: (String, String) -> Either ParseError (Path, Filter)
+pRequestFilter :: (Text, Text) -> Either ParseError (Path, Filter)
 pRequestFilter (k, v) = (,) <$> path <*> (Filter <$> fld <*> op <*> val)
   where
-    treePath = parse pTreePath ("failed to parser tree path (" ++ k ++ ")") k
-    opVal = parse pOpValueExp ("failed to parse filter (" ++ v ++ ")") v
+    treePath = parse pTreePath ("failed to parser tree path (" ++ toS k ++ ")") $ toS k
+    opVal = parse pOpValueExp ("failed to parse filter (" ++ toS v ++ ")") $ toS v
     path = fst <$> treePath
     fld = snd <$> treePath
     op = fst <$> opVal
     val = snd <$> opVal
 
-pRequestOrder :: (String, String) -> Either ParseError (Path, [OrderTerm])
-pRequestOrder (k, v) = (,) <$> path <*> ord
+pRequestOrder :: (Text, Text) -> Either ParseError (Path, [OrderTerm])
+pRequestOrder (k, v) = (,) <$> path <*> ord'
   where
-    treePath = parse pTreePath ("failed to parser tree path (" ++ k ++ ")") k
+    treePath = parse pTreePath ("failed to parser tree path (" ++ toS k ++ ")") $ toS k
     path = fst <$> treePath
-    ord = parse pOrder ("failed to parse order (" ++ v ++ ")") v
+    ord' = parse pOrder ("failed to parse order (" ++ toS v ++ ")") $ toS v
 
-pRequestRange :: (String, NonnegRange) -> Either ParseError (Path, NonnegRange)
+pRequestRange :: (ByteString, NonnegRange) -> Either ParseError (Path, NonnegRange)
 pRequestRange (k, v) = (,) <$> path <*> pure v
   where
-    treePath = parse pTreePath ("failed to parser tree path (" ++ k ++ ")") k
+    treePath = parse pTreePath ("failed to parser tree path (" ++ toS k ++ ")") $ toS k
     path = fst <$> treePath
 
 ws :: Parser Text
-ws = cs <$> many (oneOf " \t")
+ws = toS <$> many (oneOf " \t")
 
 lexeme :: Parser a -> Parser a
 lexeme p = ws *> p <* ws
@@ -72,13 +68,13 @@ pFieldTree = try (Node <$> pSimpleSelect <*> between (char '{') (char '}') pFiel
           <|>     Node <$> pSelect <*> pure []
 
 pStar :: Parser Text
-pStar = cs <$> (string "*" *> pure ("*"::String))
+pStar = toS <$> (string "*" *> pure ("*"::ByteString))
 
 
 pFieldName :: Parser Text
 pFieldName = do
   matches <- (many1 (letter <|> digit <|> oneOf "_") `sepBy1` dash) <?> "field name (* or [a..z0..9_])"
-  return $ intercalate "-" $ map cs matches
+  return $ intercalate "-" $ map toS matches
   where
     isDash :: GenParser Char st ()
     isDash = try ( char '-' >> notFollowedBy (char '>') )
@@ -87,10 +83,10 @@ pFieldName = do
 
 
 pJsonPathStep :: Parser Text
-pJsonPathStep = cs <$> try (string "->" *> pFieldName)
+pJsonPathStep = toS <$> try (string "->" *> pFieldName)
 
 pJsonPath :: Parser [Text]
-pJsonPath = (++) <$> many pJsonPathStep <*> ( (:[]) <$> (string "->>" *> pFieldName) )
+pJsonPath = (<>) <$> many pJsonPathStep <*> ( (:[]) <$> (string "->>" *> pFieldName) )
 
 pField :: Parser Field
 pField = lexeme $ (,) <$> pFieldName <*> optionMaybe pJsonPath
@@ -111,25 +107,25 @@ pSelect = lexeme $
     do
       alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
       fld <- pField
-      cast <- optionMaybe (string "::" *> many letter)
-      return (fld, cs <$> cast, alias)
+      cast' <- optionMaybe (string "::" *> many letter)
+      return (fld, toS <$> cast', alias)
   )
   <|> do
     s <- pStar
     return ((s, Nothing), Nothing, Nothing)
 
 pOperator :: Parser Operator
-pOperator = cs <$> (pOp <?> "operator (eq, gt, ...)")
-  where pOp = foldl (<|>) empty $ map (try . string . cs . fst) operators
+pOperator = toS <$> (pOp <?> "operator (eq, gt, ...)")
+  where pOp = foldl (<|>) empty $ map (try . string . toS . fst) operators
 
 pValue :: Parser FValue
-pValue = VText <$> (cs <$> many anyChar)
+pValue = VText <$> (toS <$> many anyChar)
 
 pDelimiter :: Parser Char
 pDelimiter = char '.' <?> "delimiter (.)"
 
 pOperatiorWithNegation :: Parser Operator
-pOperatiorWithNegation = try ( (<>) <$> ( cs <$> string "not." ) <*>  pOperator) <|> pOperator
+pOperatiorWithNegation = try ( (<>) <$> ( toS <$> string "not." ) <*>  pOperator) <|> pOperator
 
 pOpValueExp :: Parser (Operator, FValue)
 pOpValueExp = (,) <$> pOperatiorWithNegation <*> (pDelimiter *> pValue)
@@ -150,4 +146,4 @@ pOrderTerm =
            ))
     return $ OrderTerm c d nls
   )
-  <|> OrderTerm <$> (cs <$> pFieldName) <*> pure OrderAsc <*> pure Nothing
+  <|> OrderTerm <$> (toS <$> pFieldName) <*> pure OrderAsc <*> pure Nothing