Merge pull request #2 from chenyan2002/dev

dev
dfinity · Apr 25, 2021 · 8621031 · 8621031
2 parents 0735b57 + e8aa1a7
commit 8621031
Show file tree

Hide file tree

Showing 5 changed files with 50 additions and 22 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/README.md b/README.md
@@ -1,7 +1,7 @@
 # Canister REPL
 
 ```
-ic-repl --replica [local|ic|url]
+ic-repl --replica [local|ic|url] --config <dhall config> [script file]
 ```
 
 ## Commands
@@ -15,9 +15,24 @@ ic-repl --replica [local|ic|url]
  | call <name> . <name> ( <val>,* )
  | let <id> = <val>
  | show <val>
- | assert <val> = <val>
+ | assert <val> <==|~=|!=> <val>
  | identity <id>
 
 <var> := <id> | _
 <val> := <candid val> | <var> (. <id>)*
 ```
+
+## Example
+
+test.sh
+```
+#!/usr/bin/ic-repl -r ic
+
+import greet = "rrkah-fqaaa-aaaaa-aaaaq-cai";
+call greet.greet("test");
+let result = _;
+assert _ == "Hello, test!";
+identity alice;
+call "rrkah-fqaaa-aaaaa-aaaaq-cai".greet("test");
+assert _ == result;
+```
diff --git a/src/command.rs b/src/command.rs
@@ -37,12 +37,18 @@ pub enum Command {
     Config(String),
     Show(Value),
     Let(String, Value),
-    Assert(Value, Value),
+    Assert(BinOp, Value, Value),
     Export(String),
     Import(String, Principal),
     Load(String),
     Identity(String),
 }
+#[derive(Debug, Clone)]
+pub enum BinOp {
+    Equal,
+    SubEqual,
+    NotEqual,
+}
 
 impl Command {
     pub fn run(&self, helper: &mut MyHelper) -> anyhow::Result<()> {
@@ -90,22 +96,24 @@ impl Command {
                 let v = val.get(&helper.env)?.clone();
                 helper.env.0.insert(id.to_string(), v);
             }
-            Command::Assert(left, right) => {
+            Command::Assert(op, left, right) => {
                 let left = left.get(&helper.env)?;
                 let right = right.get(&helper.env)?;
-                if left != right {
-                    let l_ty = left.value_ty();
-                    let r_ty = right.value_ty();
-                    //println!("{} {}", l_ty, r_ty);
-                    let env = TypeEnv::new();
-                    //left.annotate_type(false, &env, &r_ty)?;
-                    if let Ok(ref left) = left.annotate_type(false, &env, &r_ty) {
-                        assert_eq!(left, right);
-                    } else if let Ok(ref right) = right.annotate_type(false, &env, &l_ty) {
-                        assert_eq!(left, right);
-                    } else {
-                        assert_eq!(left, right);
+                match op {
+                    BinOp::Equal => assert_eq!(left, right),
+                    BinOp::SubEqual => {
+                        let l_ty = left.value_ty();
+                        let r_ty = right.value_ty();
+                        let env = TypeEnv::new();
+                        if let Ok(ref left) = left.annotate_type(false, &env, &r_ty) {
+                            assert_eq!(left, right);
+                        } else if let Ok(ref right) = right.annotate_type(false, &env, &l_ty) {
+                            assert_eq!(left, right);
+                        } else {
+                            assert_eq!(left, right);
+                        }
                     }
+                    BinOp::NotEqual => assert!(left != right),
                 }
             }
             Command::Config(conf) => helper.config = Configs::from_dhall(&conf)?,

diff --git a/src/grammar.lalrpop b/src/grammar.lalrpop
@@ -1,9 +1,9 @@
-use candid::parser::value::{IDLField, IDLValue, IDLArgs};
+use candid::parser::value::{IDLField, IDLValue, IDLArgs, VariantValue};
 use candid::parser::types::{IDLType, TypeField, PrimType, FuncType, FuncMode, Binding};
 use candid::parser::typing::{TypeEnv, check_unique};
 use super::token::{Token, error2, LexicalError, Span, Spanned};
 use candid::{Principal, types::Label};
-use super::command::{Command, Commands, Value};
+use super::command::{Command, Commands, Value, BinOp};
 
 grammar;
 
@@ -41,6 +41,7 @@ extern {
         "sign" => Token::Sign(<char>),
         "=" => Token::Equals,
         "==" => Token::TestEqual,
+        "~=" => Token::SubEqual,
         "!=" => Token::NotEqual,
         "(" => Token::LParen,
         ")" => Token::RParen,
@@ -72,7 +73,9 @@ pub Command: Command = {
     },
     "config" <Text> => Command::Config(<>),
     "show" <Value> => Command::Show(<>),
-    "assert" <left:Value> "==" <right:Value> => Command::Assert(left, right),
+    "assert" <left:Value> "==" <right:Value> => Command::Assert(BinOp::Equal, left, right),
+    "assert" <left:Value> "~=" <right:Value> => Command::Assert(BinOp::SubEqual, left, right),
+    "assert" <left:Value> "!=" <right:Value> => Command::Assert(BinOp::NotEqual, left, right),
     "let" <id:"id"> "=" <val:Value> => Command::Let(id, val),
     "export" <Text> => Command::Export(<>),
     "load" <Text> => Command::Load(<>),
@@ -130,7 +133,7 @@ Arg: IDLValue = {
         check_unique(fs.iter().map(|f| &f.id)).map_err(|e| error2(e, span))?;
         Ok(IDLValue::Record(fs))
     },
-    "variant" "{" <VariantField> "}" => IDLValue::Variant(Box::new(<>), 0),
+    "variant" "{" <VariantField> "}" => IDLValue::Variant(VariantValue(Box::new(<>), 0)),
     "principal" <Sp<Text>> =>? Ok(IDLValue::Principal(Principal::from_text(&<>.0).map_err(|e| error2(e, <>.1))?)),
     "service" <Sp<Text>> =>? Ok(IDLValue::Service(Principal::from_text(&<>.0).map_err(|e| error2(e, <>.1))?)),
     "func" <id:Sp<Text>> "." <meth:Name> =>? {

diff --git a/src/token.rs b/src/token.rs
@@ -72,6 +72,8 @@ pub enum Token {
     Load,
     #[token("==")]
     TestEqual,
+    #[token("~=")]
+    SubEqual,
     #[token("!=")]
     NotEqual,
     #[token("principal")]