Skip to content

A peer-to-peer stack for code collaboration

16.3 KB
Raw Blame
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Radicle.Repl where

import           Protolude hiding (TypeError, toList)

import qualified Data.Map as Map
import qualified Data.Text as T
import           GHC.Exts (IsList(..))
import           System.Console.Haskeline
                 ( CompletionFunc
                 , InputT
                 , completeWord
                 , defaultSettings
                 , getInputLine
                 , historyFile
                 , outputStrLn
                 , runInputT
                 , setComplete
                 , simpleCompletion
                 )

import           Radicle.Lang.Core
import           Radicle.Lang.Crypto
import           Radicle.Lang.Eval
import           Radicle.Lang.Identifier (Ident(..), unsafeToIdent)
import qualified Radicle.Lang.Internal.Time as Time
import qualified Radicle.Lang.Internal.UUID as UUID
import           Radicle.Lang.Interpret
import           Radicle.Lang.Number (isInt)
import           Radicle.Lang.Parse
import           Radicle.Lang.Pretty
import           Radicle.Lang.PrimFns
import           Radicle.Lang.Type (Type(..))
import           Radicle.Repl.Capabilities

type ReplM m =
    ( Monad m, Stdout (Lang m), Stdin (Lang m)
    , MonadRandom m, UUID.MonadUUID m
    , CurrentTime m
    , ReadFile (Lang m)
    , System m
    , GetEnv (Lang m) Value
    , SetEnv (Lang m) Value
    , FileModule (Lang m))

instance MonadRandom (InputT IO) where
    getRandomBytes = liftIO . getRandomBytes
instance MonadRandom m => MonadRandom (LangT (Bindings (PrimFns m)) m) where
    getRandomBytes = lift . getRandomBytes

instance UUID.MonadUUID (InputT IO) where
    uuid = liftIO UUID.uuid
instance UUID.MonadUUID m => UUID.MonadUUID (LangT (Bindings (PrimFns m)) m) where
    uuid = lift UUID.uuid

putPrettyAnsi' :: (PrettyV v, Stdout m) => v -> m ()
putPrettyAnsi' value = do
  supportsANSI' <- bool NoANSISupport ANSISupport <$> supportsANSI
  putPrettyAnsi putStrS supportsANSI' value

script :: Text -> Text -> Bindings (PrimFns IO) -> IO ExitCode
script fileName code bindings = do
    r <- fmap fst <$> runLang bindings $ interpretMany fileName $ ignoreShebang code
    case r of
        Left (LangError _ (Exit n)) -> pure (exitCode n)
        Left e -> do putPrettyAnsi' e
                     pure $ ExitFailure 1
        Right x -> do putPrettyAnsi' x
                      pure ExitSuccess

-- TODO: restore error preCode?
repl :: Maybe FilePath -> Text -> Bindings (PrimFns (InputT IO)) -> IO ()
repl histFile _ bindings = do
    let settings = setComplete completion
                 $ defaultSettings { historyFile = histFile }
    runInputT settings $ loop bindings
  where
    loop :: Bindings (PrimFns (InputT IO)) -> InputT IO ()
    loop st = do
        ln <- fmap toS <$> getInputLine "rad> "
        case ln of
            Nothing -> loop st
            Just ln'  -> do
                parsed <- parseREPL (fmap toS <$> getInputLine "...  ") ln'
                case parsed of
                    Left e -> outputStrLn e >> loop st
                    Right v -> do
                        (res, newSt) <- runLang st (eval v)
                        case res of
                            Left e'  -> putPrettyAnsi' e' >> loop st
                            Right v' -> putPrettyAnsi' v' >> loop newSt

exitCode :: Int -> ExitCode
exitCode 0 = ExitSuccess
exitCode n = ExitFailure n

completion :: Monad m => CompletionFunc m
completion = completeWord Nothing ['(', ')', ' ', '\n'] go
  where
    -- Any type for first param will do
    bnds :: Bindings (PrimFns (InputT IO))
    bnds = replBindings []

    go s = pure $ fmap simpleCompletion
         $ filter (s `isPrefixOf`)
         $ fmap (T.unpack . fromIdent)
         $ (Map.keys . fromEnv $ bindingsEnv bnds)
        <> Map.keys (getPrimFns $ bindingsPrimFns bnds)

replBindings :: ReplM m => [Text] -> Bindings (PrimFns m)
replBindings sysArgs = addPrimFns (replPrimFns sysArgs) pureEnv

replPrimFns :: ReplM m => [Text] -> PrimFns m
replPrimFns sysArgs = fromList $ allDocs $
    [ ( "get-args!"
      , "Returns the list of the command-line arguments the script was called with"
      , \case
          [] -> pure . Vec $ fromList (String <$> sysArgs)
          xs -> throwErrorHere $ WrongNumberOfArgs "get-args!" 0 (length xs)
      )
    , ("put-str!"
      , "Prints a string."
      , oneArg "put-str!" $ \case
        (String x) -> do
            putStrS x
            pure nil
        v -> throwErrorHere $ TypeError "put-str!" 0 TString v
      )
    -- Note to self: 'doc!' has to remain a primfn. Defining it as a lambda in
    -- radicle itself is futile but you are welcome to try.
    , ( "doc!"
      , "Prints the documentation attached to a value and returns `()`. To retrieve\
        \ the docstring as a value use `doc` instead."
      , oneArg "doc!" $ \case
          Atom i -> do
            d <- lookupAtomDoc i
            putStrS $ fromMaybe (missingDocMsg i) d
            pure nil
          v -> throwErrorHere $ TypeError "doc!" 0 TAtom v
      )

    , ( "apropos!"
      , "Prints documentation for all documented variables in scope."
      , noArg "apropos!" $ do
            env <- gets bindingsEnv
            let docs = [ i <> "\n" <> doc | (Ident i, Just doc, _) <- toList env ]
            putStrS (T.intercalate "\n\n" docs)
            pure nil
      )

    , ( "get-line!"
      , "Reads a single line of input and returns it as a string."
      , \case
          [] -> maybe nil toRad <$> getLineS
          xs -> throwErrorHere $ WrongNumberOfArgs "get-line!" 0 (length xs)
      )

    , ("subscribe-to!"
      , "Expects a dict `s` (representing a subscription) and a function `f`. The dict\
        \ `s` should have a function `getter` at the key `:getter`. This function is called\
        \ repeatedly (with no arguments), its result is then evaluated and passed to `f`."
      , \case
        [x, v] -> do
            e <- gets bindingsEnv
            case (x, v) of
                (Dict m, fn) -> case Map.lookup (Keyword $ unsafeToIdent "getter") m of
                    Nothing -> throwErrorHere
                        $ OtherError "subscribe-to!: Expected ':getter' key"
                    Just g -> loop go
                      where
                        loop action = do
                            st <- get
                            join $ (action >> pure (loop action)) `catchError`
                                (\err -> case err of
                                   LangError _ (Exit _) -> pure (pure nil)
                                   LangError _ (Impossible _) -> do
                                       putPrettyAnsi' err
                                       throwError err
                                   _ -> do
                                       putPrettyAnsi' err
                                       put st
                                       pure (loop action))
                        go = do
                            -- We need to evaluate the getter in the original
                            -- environment in which it was defined, but the
                            -- /result/ of the getter is then evaluated in the
                            -- current environment.
                            y <- g $$ []
                            case y of
                              Vec ys -> do
                                ys' <- traverse eval ys
                                -- Similarly, the application of the subscriber
                                -- function is evaluated in the original
                                -- environment.
                                void $ withEnv (const e) (fn $$ [quote (Vec ys')])
                              _ -> throwErrorHere $ OtherError "Getter should return a vector of values"
                _  -> throwErrorHere $ TypeError "subscribe-to!" 0 TDict x
        xs  -> throwErrorHere $ WrongNumberOfArgs "subscribe-to!" 2 (length xs))
    , ( "read-file!"
      , "Reads the contents of a file and returns it as a string."
      , oneArg "read-file" $ \case
          String filename -> readFileS filename >>= \case
              Left err -> throwErrorHere . OtherError $ "Error reading file: " <> err
              Right text -> pure $ String text
          v -> throwErrorHere $ TypeError "read-file!" 0 TString v
      )
    , ( "open-file!"
      , "Open file in the specified mode (`:read`, `:write`, `:append`, `:read-write`)."
      , twoArg "open-file!" $ \case
          (String file, Keyword (Ident mode)) -> do
              mode' <- case mode of
                  "read" -> pure ReadMode
                  "write" -> pure WriteMode
                  "append" -> pure AppendMode
                  "read-write" -> pure ReadWriteMode
                  x -> throwErrorHere
                     . OtherError
                     $ "Expected one of :read, :write, :append, or :read-write."
                    <> "Got: " <> x
              res <- openFileS file mode'
              case res of
                  Left e  -> throwErrorHere . OtherError $ "open-file!:" <> e
                  Right v -> newHandle v
          (v, Keyword _) -> throwErrorHere $ TypeError "open-file!" 0 TString v
          (_, v) -> throwErrorHere $ TypeError "open-file!" 1 TKeyword v
      )
    , ( "load!"
      , "Evaluates the contents of a file. Each seperate radicle expression is\
        \ `eval`uated according to the current definition of `eval`."
      , oneArg "load!" $ \case
          String filename -> readFileS filename >>= \case
              Left err -> throwErrorHere . OtherError $ "Error reading file: " <> err
              Right text -> interpretMany filename (ignoreShebang text)
          v -> throwErrorHere $ TypeError "load!" 0 TString v
      )
    , ( "gen-key-pair!"
      , "Given an elliptic curve, generates a cryptographic key-pair. Use\
        \ `default-ecc-curve` for a default value for the elliptic curve."
      , oneArg "gen-key-pair!" $ \case
          curvev -> do
            curve <- hoistEither . first (toLangError . OtherError) $ fromRad curvev
            (pk, sk) <- generateKeyPair curve
            let pkv = toRad pk
            let skv = toRad sk
            pure . Dict . Map.fromList $
              [ (Keyword (Ident "private-key"), skv)
              , (Keyword (Ident "public-key"), pkv)
              ]
      )
    , ( "gen-signature!"
      , "Given a private key and a message (a string), generates a cryptographic\
        \ signature for the message."
      , twoArg "gen-signature!" $ \case
          (skv, String msg) -> do
            sk <- hoistEither . first (toLangError . OtherError) $ fromRad skv
            toRad <$> signText sk msg
          (_, v) -> throwErrorHere $ TypeError "gen-signature!" 1 TString v
      )
    , ( "uuid!"
      , "Generates a random UUID."
      , \case
          [] -> String <$> UUID.uuid
          xs -> throwErrorHere $ WrongNumberOfArgs "uuid!" 0 (length xs)
      )
    , ( "system!"
      , "(system! proc) execute a system process. Returns the dict with the form\
        \ ```\
        \    { :stdin maybe-handle\
        \      :stdout maybe-handle\
        \      :stderr maybe-handle\
        \      :proc prochandle\
        \    }\
        \ ```\
        \ Where `maybe-handle` is either `[:just handle]` or `:nothing`.\
        \ Note that this is quite a low-level function; higher-level ones are more convenient."
      , oneArg "system!" $ \proc -> do
          proc' <- hoistEither $ first (toLangError . OtherError) $ fromRad proc
          res <- systemS proc'
          let ifJustCreate x = case x of
                Nothing -> pure Nothing
                Just v  -> Just <$> newHandle v
          case res of
              (a, b, c, ph) -> do
                  a' <- ifJustCreate a
                  b' <- ifJustCreate b
                  c' <- ifJustCreate c
                  ph' <- newProcessHandle ph
                  pure $ Dict $ Map.fromList $ first (Keyword . Ident) <$>
                    [ ("stdin", toRad a')
                    , ("stdout", toRad b')
                    , ("stderr", toRad c')
                    , ("proc", toRad ph')
                    ]
      )
    , ( "stdin!"
      , "A handle for standard in."
      , noArg "stdin!" $ pure $ Handle StdIn
      )
    , ( "stdout!"
      , "A handle for standard out."
      , noArg "stdout!" $ pure $ Handle StdIn
      )
    , ( "stderr!"
      , "A handle for standard error."
      , noArg "stderr!" $ pure $ Handle StdErr
      )
    , ( "write-handle!"
      , "Write a string to the provided handle."
      , twoArg "write-handle!" $ \case
          (Handle h, String msg) -> do
              h' <- lookupHandle h
              hPutStrS h' msg
              pure $ Keyword $ Ident "ok"
          (Handle _, v) -> throwErrorHere $ TypeError "write-handle!" 1 TString v
          (v, _) -> throwErrorHere $ TypeError "write-handle!" 0 THandle v
      )
    , ( "read-line-handle!"
      , "Read a single line from a handle. Returns the string read, or the\
        \ keyword `:eof` if an EOF is encountered."
      , oneArg "read-line-handle!" $ \case
          Handle h -> do
              h' <- lookupHandle h
              hGetLineS h' >>= \case
                  Nothing -> pure . Keyword $ Ident "eof"
                  Just v -> pure $ String v
          v -> throwErrorHere $ TypeError "read-line-handle!" 0 THandle v
      )
    , ( "wait-for-process!"
      , "Block until process terminates."
      , oneArg "wait-for-process!" $ \case
          ProcHandle h -> do
              h' <- lookupProcHandle h
              toRad <$> waitForProcessS h'
          v -> throwErrorHere $ TypeError "wait-for-process!" 0 TProcHandle v
      )
    , ( "close-handle!"
      , "Close a handle"
      , oneArg "close-handle!" $ \case
          Handle h -> do
              h' <- lookupHandle h
              toRad <$> hCloseS h'
          v -> throwErrorHere $ TypeError "wait-for-process!" 0 TProcHandle v
      )
    , ( "exit!"
      , "Exit the interpreter immediately with the given exit code."
      , oneArg "exit!" $ \case
          Number q -> case isInt q of
            Left _ -> throwErrorHere $ OtherError $ "exit!: number is not an integer"
            Right n -> throwErrorHere $ Exit n
          v -> throwErrorHere $ TypeError "exit!" 0 TNumber v
      )
    , ( "now!"
      , "Returns a timestamp for the current Coordinated Universal Time (UTC), right now, formatted according to ISO 8601."
      , \case
          [] -> do t <- currentTime
                   pure . String . Time.formatTime $ t
          xs -> throwErrorHere $ WrongNumberOfArgs "exit!" 0 (length xs)
      )
    , ( "file-module!"
      , "Given a file whose code starts with module metadata, creates the module.\
        \ That is, the file is evaluated as if the code was wrapped in `(module ...)`."
      , oneArg "file-module!" $ \case
          String filename -> do
            ef <- fileModuleS filename
            file <- case ef of
                Nothing -> throwError . toLangError . OtherError $ "File not found in RADPATH: " <> filename
                Just f -> pure f
            t_ <- fmap ignoreShebang <$> readFileS file
            t <- hoistEither . first (toLangError . OtherError) $ t_
            vs <- readValues filename t
            createModule vs
          v -> throwErrorHere $ TypeError "file-module!" 0 TString v
      )
    , ( "find-module-file!"
      , "Find a file according to radicle search path rules. These are: \
        \ 1) If RADPATH is set, first search there; \
        \ 2) If RADPATH is not set, search in the distribution directory \
        \ 3) If the file is still not found, search in the current directory."
      , oneArg "find-module-file!" $ \case
          String filename -> do
            t_ <- fileModuleS filename
            case t_ of
                Nothing -> throwError . toLangError . OtherError $ "File not found in RADPATH: " <> filename
                Just t  -> pure $ String t
          v -> throwErrorHere $ TypeError "find-module-file!" 0 TString v
      )
    , ( "cd!"
      , "Change the current working directory."
      , oneArg "cd!" $ \case
          String filename -> do
              setCurrentDirS $ toS filename
              pure $ Keyword $ Ident "ok"
          v -> throwErrorHere $ TypeError "cd!" 0 TString v
      )
    ]

-- | Since `#` is not a comment in radicle, we need to explictly remove shebang
-- lines.
ignoreShebang :: Text -> Text
ignoreShebang src = case T.lines src of
    f:rest -> T.unlines $ if "#!" `T.isPrefixOf` f then mempty:rest else f:rest
    _      -> src