From 1f01fafec73eb3191f6dd52b0b552e54b92cf705 Mon Sep 17 00:00:00 2001 From: Benjamin Peterson Date: Tue, 27 Oct 2009 16:45:51 -0500 Subject: [PATCH] can't use .format() on jython :( --HG-- branch : trunk --- _py/code/_assertionnew.py | 76 +++++++++++++++++++-------------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/_py/code/_assertionnew.py b/_py/code/_assertionnew.py index 1213eb1fe..6192c714d 100644 --- a/_py/code/_assertionnew.py +++ b/_py/code/_assertionnew.py @@ -66,9 +66,9 @@ def getfailure(failure): lines = explanation.splitlines() if not lines: lines.append("") - lines[0] += " << {0}".format(value) + lines[0] += " << %s" % (value,) explanation = "\n".join(lines) - text = "{0}: {1}".format(failure.cause[0].__name__, explanation) + text = "%s: %s" % (failure.cause[0].__name__, explanation) if text.startswith("AssertionError: assert "): text = text[16:] return text @@ -99,10 +99,10 @@ operator_map = { } unary_map = { - ast.Not : "not {0}", - ast.Invert : "~{0}", - ast.USub : "-{0}", - ast.UAdd : "+{0}" + ast.Not : "not %s", + ast.Invert : "~%s", + ast.USub : "-%s", + ast.UAdd : "+%s" } @@ -147,7 +147,7 @@ class DebugInterpreter(ast.NodeVisitor): def visit_Name(self, name): explanation, result = self.generic_visit(name) # See if the name is local. - source = "{0!r} in locals() is not globals()".format(name.id) + source = "%r in locals() is not globals()" % (name.id,) co = self._compile(source) try: local = self.frame.eval(co) @@ -167,9 +167,9 @@ class DebugInterpreter(ast.NodeVisitor): break next_explanation, next_result = self.visit(next_op) op_symbol = operator_map[op.__class__] - explanation = "{0} {1} {2}".format(left_explanation, op_symbol, - next_explanation) - source = "__exprinfo_left {0} __exprinfo_right".format(op_symbol) + explanation = "%s %s %s" % (left_explanation, op_symbol, + next_explanation) + source = "__exprinfo_left %s __exprinfo_right" % (op_symbol,) co = self._compile(source) try: result = self.frame.eval(co, __exprinfo_left=left_result, @@ -196,8 +196,8 @@ class DebugInterpreter(ast.NodeVisitor): def visit_UnaryOp(self, unary): pattern = unary_map[unary.op.__class__] operand_explanation, operand_result = self.visit(unary.operand) - explanation = pattern.format(operand_explanation) - co = self._compile(pattern.format("__exprinfo_expr")) + explanation = pattern % (operand_explanation,) + co = self._compile(pattern % ("__exprinfo_expr",)) try: result = self.frame.eval(co, __exprinfo_expr=operand_result) except Exception: @@ -208,9 +208,9 @@ class DebugInterpreter(ast.NodeVisitor): left_explanation, left_result = self.visit(binop.left) right_explanation, right_result = self.visit(binop.right) symbol = operator_map[binop.op.__class__] - explanation = "({0} {1} {2})".format(left_explanation, symbol, - right_explanation) - source = "__exprinfo_left {0} __exprinfo_right".format(symbol) + explanation = "(%s %s %s)" % (left_explanation, symbol, + right_explanation) + source = "__exprinfo_left %s __exprinfo_right" % (symbol,) co = self._compile(source) try: result = self.frame.eval(co, __exprinfo_left=left_result, @@ -226,33 +226,33 @@ class DebugInterpreter(ast.NodeVisitor): arguments = [] for arg in call.args: arg_explanation, arg_result = self.visit(arg) - arg_name = "__exprinfo_{0}".format(len(ns)) + arg_name = "__exprinfo_%s" % (len(ns),) ns[arg_name] = arg_result arguments.append(arg_name) arg_explanations.append(arg_explanation) for keyword in call.keywords: arg_explanation, arg_result = self.visit(keyword.value) - arg_name = "__exprinfo_{0}".format(len(ns)) + arg_name = "__exprinfo_%s" % (len(ns),) ns[arg_name] = arg_result - keyword_source = "{0}={{0}}".format(keyword.id) - arguments.append(keyword_source.format(arg_name)) - arg_explanations.append(keyword_source.format(arg_explanation)) + keyword_source = "%s=%%s" % (keyword.id) + arguments.append(keyword_source % (arg_name,)) + arg_explanations.append(keyword_source % (arg_explanation,)) if call.starargs: arg_explanation, arg_result = self.visit(call.starargs) arg_name = "__exprinfo_star" ns[arg_name] = arg_result - arguments.append("*{0}".format(arg_name)) - arg_explanations.append("*{0}".format(arg_explanation)) + arguments.append("*%s" % (arg_name,)) + arg_explanations.append("*%s" % (arg_explanation,)) if call.kwargs: arg_explanation, arg_result = self.visit(call.kwargs) arg_name = "__exprinfo_kwds" ns[arg_name] = arg_result - arguments.append("**{0}".format(arg_name)) - arg_explanations.append("**{0}".format(arg_explanation)) + arguments.append("**%s" % (arg_name,)) + arg_explanations.append("**%s" % (arg_explanation,)) args_explained = ", ".join(arg_explanations) - explanation = "{0}({1})".format(func_explanation, args_explained) + explanation = "%s(%s)" % (func_explanation, args_explained) args = ", ".join(arguments) - source = "__exprinfo_func({0})".format(args) + source = "__exprinfo_func(%s)" % (args,) co = self._compile(source) try: result = self.frame.eval(co, **ns) @@ -269,14 +269,14 @@ class DebugInterpreter(ast.NodeVisitor): except Exception: is_bool = False if not is_bool: - pattern = "{0}\n{{{0} = {1}\n}}" + pattern = "%s\n{%s = %s\n}" rep = self.frame.repr(result) - explanation = pattern.format(rep, explanation) + explanation = pattern % (rep, rep, explanation) return explanation, result def _is_builtin_name(self, name): - pattern = "{0!r} not in globals() and {0!r} not in locals()" - source = pattern.format(name.id) + pattern = "%r not in globals() and %r not in locals()" + source = pattern % (name.id, name.id) co = self._compile(source) try: return self.frame.eval(co) @@ -287,16 +287,16 @@ class DebugInterpreter(ast.NodeVisitor): if not isinstance(attr.ctx, ast.Load): return self.generic_visit(attr) source_explanation, source_result = self.visit(attr.value) - explanation = "{0}.{1}".format(source_explanation, attr.attr) - source = "__exprinfo_expr.{0}".format(attr.attr) + explanation = "%s.%s" % (source_explanation, attr.attr) + source = "__exprinfo_expr.%s" % (attr.attr,) co = self._compile(source) try: result = self.frame.eval(co, __exprinfo_expr=source_result) except Exception: raise Failure(explanation) # Check if the attr is from an instance. - source = "{0!r} in getattr(__exprinfo_expr, '__dict__', {{}})" - source = source.format(attr.attr) + source = "%r in getattr(__exprinfo_expr, '__dict__', {})" + source = source % (attr.attr,) co = self._compile(source) try: from_instance = self.frame.eval(co, __exprinfo_expr=source_result) @@ -304,8 +304,8 @@ class DebugInterpreter(ast.NodeVisitor): from_instance = True if from_instance: rep = self.frame.repr(result) - pattern = "{0}\n{{{0} = {1}\n}}" - explanation = pattern.format(rep, explanation) + pattern = "%s\n{%s = %s\n}" + explanation = pattern % (rep, rep, explanation) return explanation, result def visit_Assert(self, assrt): @@ -313,7 +313,7 @@ class DebugInterpreter(ast.NodeVisitor): if test_explanation.startswith("False\n{False =") and \ test_explanation.endswith("\n"): test_explanation = test_explanation[15:-2] - explanation = "assert {0}".format(test_explanation) + explanation = "assert %s" % (test_explanation,) if not test_result: try: raise BuiltinAssertionError @@ -323,7 +323,7 @@ class DebugInterpreter(ast.NodeVisitor): def visit_Assign(self, assign): value_explanation, value_result = self.visit(assign.value) - explanation = "... = {0}".format(value_explanation) + explanation = "... = %s" % (value_explanation,) name = ast.Name("__exprinfo_expr", ast.Load(), assign.value.lineno, assign.value.col_offset) new_assign = ast.Assign(assign.targets, name, assign.lineno,