def toString(self, context: Context): try: writer = CodeWriter(Dialect.E, context) self.toDialect(writer) return writer.__str__() except: return ""
def bodyToDialect(self, writer: CodeWriter): from prompto.statement.ReturnStatement import ReturnStatement if len(self.statements) == 1 and isinstance(self.statements[0], ReturnStatement): self.statements[0].expression.toDialect(writer) else: writer.append("{").newLine().indent() self.statements.toDialect(writer) writer.newLine().dedent().append("}").newLine()
def testCanParseAndTranslateMultilineAttributes(self): jsx = "return <a \n\tx=\"abc\"\n\ty=\"def\"\n\tz=\"stuff\" />;" parser = OCleverParser(text=jsx) stmt = parser.doParse(parser.return_statement) self.assertIsNotNone(stmt.expression) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) stmt.toDialect(writer) writer.append(";") out = str(writer) self.assertEquals(jsx, out)
def testCanParseAndTranslateMultilineElements(self): jsx = "return <a>\n\t<b/>\n\t<b/>\n</a>;" parser = OCleverParser(text=jsx) stmt = parser.doParse(parser.return_statement) self.assertIsNotNone(stmt.expression) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) stmt.toDialect(writer) writer.append(";") out = str(writer) self.assertEquals(jsx, out)
def testMethodCallWith(self): statement = "print(value = \"person\" + p.name);" mc = self.parse(statement, OParser.method_call_statement) self.assertIsNotNone(mc) self.assertEquals("print", mc.caller.name) self.assertIsNotNone(mc.arguments) arg = mc.arguments[0] self.assertEquals("value", arg.getName()) exp = arg.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) mc.toDialect(writer) writer.append(';') self.assertEquals(statement, str(writer))
def interpretAssert(self, context, test): lval = self.left.interpret(context) rval = self.right.interpret(context) result = self.interpretValue(context, lval, rval) if result is BooleanValue.TRUE: return True writer = CodeWriter(test.dialect, context) self.toDialect(writer) expected = str(writer) writer = CodeWriter(test.dialect, context) self.operator.toDialect(writer) actual = str(lval) + " " + str(writer) + " " + str(rval) test.printFailedAssertion(context, expected, actual) return False
def testMethodWith(self): statement = "print \"a\" with \"1\" as value" stmt = self.parse(statement, ECleverParser.statement) self.assertIsNotNone(stmt) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) stmt.toDialect(writer) self.assertEquals(statement, str(writer))
def testMethodWith(self): statement = "print(\"a\", value = \"1\");" stmt = self.parse(statement, OParser.statement) self.assertIsNotNone(stmt) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) stmt.toDialect(writer) self.assertEquals(statement, str(writer) + ";")
def argsToDialect(self, writer: CodeWriter): if self.args is None or len(self.args) == 0: writer.append("()") elif len(self.args) == 1: writer.append(self.args[0]) else: writer.append("(") self.args.toDialect(writer, False) writer.append(")")
def interpretAssert(self, context, testMethodDeclaration): self.resolve(context) if getattr(self.resolved, "interpretAssert", None) is not None: return self.resolved.interpretAssert(context, testMethodDeclaration) else: writer = CodeWriter(self.dialect, context) self.resolved.toDialect(writer) raise SyntaxError("Cannot test '" + str(writer) + "'")
def testNativeSymbol(self): statement = "ENTITY_1 with \"1\" as value" symbol = self.parse(statement, ECleverParser.native_symbol) self.assertIsNotNone(symbol) self.assertIsInstance(symbol, NativeSymbol) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) symbol.toDialect(writer) self.assertEquals(statement, str(writer))
def testSimpleDictLiteral(self): statement = "< \"john\" : 1234, eric : 5678 >" literal = self.parse(statement, OParser.literal_expression) self.assertIsNotNone(literal) self.assertIsInstance(literal, DictLiteral) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) literal.toDialect(writer) self.assertEquals('<"john":1234, eric:5678>', str(writer))
def testNativeSymbol(self): statement = 'ENTITY_1 = "1";' symbol = self.parse(statement, OParser.native_symbol) self.assertIsNotNone(symbol) self.assertIsInstance(symbol, NativeSymbol) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) symbol.toDialect(writer) self.assertEquals(statement, str(writer) + ";")
def interpretAssert(self, context, testMethodDeclaration): value = self.interpret(context) if isinstance(value, BooleanValue): return value.value else: writer = CodeWriter(self.dialect, context) self.toDialect(writer) raise SyntaxError("Cannot test '" + str(writer) + "'")
def testComplexArgumentAssignment(self): statement = "\"person\" + p.name as value" as_ = self.parse(statement,ECleverParser.argument_assignment) self.assertEquals("value",as_.getName()) exp = as_.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) as_.toDialect(writer) self.assertEquals(statement, str(writer))
def testSimpleArgumentAssignment(self): statement = "p.name as value" as_ = self.parse(statement,ECleverParser.argument_assignment) self.assertEquals("value",as_.getName()) exp = as_.getExpression() self.assertIsNotNone(exp) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) as_.toDialect(writer) self.assertEquals("p.name as value",str(writer))
def testRange(self): statement = "[1..100]" rl = self.parse(statement, OParser.range_literal) self.assertIsNotNone(rl) self.assertEquals("1", str(rl.getFirst())) self.assertEquals("100", str(rl.getLast())) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) rl.toDialect(writer) self.assertEquals(statement, str(writer))
def testArgumentAssignmentList1Arg(self): statement = "with \"person\" + p.name as value" ls = self.parse(statement, ECleverParser.argument_assignment_list) as_ = ls[0] self.assertEqual("value", as_.getName()) exp = as_.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) as_.toDialect(writer) self.assertEqual("\"person\" + p.name as value", str(writer))
def interpretAssert(self, context, test): val = self.expression.interpret(context) result = self.interpretValue(context, val) if result is BooleanValue.TRUE: return True writer = CodeWriter(test.dialect, context) self.toDialect(writer) expected = str(writer) actual = self.operatorToDialect(test.dialect) + str(val) test.printFailedAssertion(context, expected, actual) return False
def testMethod1Extended1Statement(self): statement = "method printName ( Object(name) o ) { print ( value = \"object\" + o.name ); }" ad = self.parse(statement, OParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = ExtendedParameter(CategoryType("Object"), "o", IdentifierList("name")) self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print(value = \"object\" + o.name)", str(writer))
def testMethod1Array1Statement(self): statement = "method printName ( Option[] options ) { print ( value = \"array\" + options ); }" ad = self.parse(statement, OParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(ListType(CategoryType("Option")), "options") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print(value = \"array\" + options)", str(writer))
def testMethod1Parameter1Statement(self): statement = "method printName ( Person p ) { print ( value = \"person\" + p.name); }" ad = self.parse(statement, OParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(CategoryType("Person"), "p") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print(value = \"person\" + p.name)", str(writer))
def testMethod1Extended1Statement(self): statement = "define printName as method receiving Object o with attribute name doing:\r\n" \ + "\tprint with \"object\" + o.name as value" ad = self.parse(statement,ECleverParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName",ad.getName()) self.assertIsNotNone(ad.parameters) expected = ExtendedParameter(CategoryType("Object"), "o", IdentifierList("name")) self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print with \"object\" + o.name as value",str(writer))
def testMethod1Array1Statement(self): statement = "define printName as method receiving Option[] options doing:\r\n" \ + "\tprint with \"array\" + args as value" ad = self.parse(statement,ECleverParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName",ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(ListType(CategoryType("Option")), "options") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print with \"array\" + args as value",str(writer))
def toDialect(self, writer: CodeWriter): self.argsToDialect(writer) if self.argsSuite is not None: writer.append(self.argsSuite) writer.append("=>") if self.arrowSuite is not None: writer.append(self.arrowSuite) self.bodyToDialect(writer)
def compareResourceEOE(self, resourceName): expected = self.getResourceAsString(resourceName, 'r') # print(expected) # parse e source code dle = self.parseEString(expected) context = Context.newGlobalContext() dle.register(context) # rewrite as o writer = CodeWriter(Dialect.O, context) dle.toDialect(writer) o = str(writer) # print(o) # parse o source code dlo = self.parseOString(o) context = Context.newGlobalContext() dlo.register(context) # rewrite as e writer = CodeWriter(Dialect.E, context) dlo.toDialect(writer) actual = str(writer) # print(actual) # ensure equivalent self.assertEquivalent(expected, actual)
def testMethodCallWith(self): statement = "print with \"person\" + p.name as value" mc = self.parse(statement, ECleverParser.method_call_statement) self.assertIsNotNone(mc) self.assertEqual("print", mc.caller.getName()) self.assertIsNotNone(mc.arguments) argument = mc.arguments[0] self.assertEqual("value", argument.getName()) exp = argument.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) mc.toDialect(writer) self.assertEqual("print with \"person\" + p.name as value", str(writer))
def testMethod1Parameter1Statement(self): statement = "define printName as method receiving Person p doing:\r\n" \ + "\tprint with \"person\" + p.name as value" ad = self.parse(statement, ECleverParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEqual("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(CategoryType("Person"), "p") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEqual("print with \"person\" + p.name as value", str(writer))
def compareResourceEME(self, resourceName): expected = self.getResourceAsString(resourceName, 'r') # print(expected) # parse e source code dle = self.parseEString(expected) context = Context.newGlobalContext() dle.register(context) # rewrite as p writer = CodeWriter(Dialect.M, context) dle.toDialect(writer) p = unicode(writer) # print(p) # parse p source code dlp = self.parseMString(p) context = Context.newGlobalContext() dlp.register(context) # rewrite as e writer = CodeWriter(Dialect.E, context) dlp.toDialect(writer) actual = unicode(writer) # print(actual) # ensure equivalent self.assertEquivalent(expected, actual)
def compareResourceOMO(self, resourceName): expected = self.getResourceAsString(resourceName, 'r') # print(expected) # parse o source code dlo = self.parseOString(expected) context = Context.newGlobalContext() dlo.register(context) # rewrite as p writer = CodeWriter(Dialect.M, context) dlo.toDialect(writer) p = str(writer) # print(p) # parse p source code dlp = self.parseMString(p) context = Context.newGlobalContext() dlp.register(context) # rewrite as o writer = CodeWriter(Dialect.O, context) dlp.toDialect(writer) actual = str(writer) # print(actual) # ensure equivalent self.assertEquivalent(expected, actual)