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)
