def test_slots_rt(): ns = Namespace("root", None) rs = Resolver(ns) e = Entity("xx", ns) qs = QueueScheduler(None, [], [], {}, set()) r = RelationAttribute(e, None, "xx", Location("", 1)) i = Instance(e, rs, qs) sa = SetAttribute(Reference("a"), "a", Literal("a")) assert_slotted(ResultVariable()) assert_slotted(AttributeVariable(None, None)) assert_slotted(Promise(None, None)) assert_slotted(ListVariable(r, i, qs)) assert_slotted(OptionVariable(r, i, qs)) assert_slotted(qs) assert_slotted(DelegateQueueScheduler(qs, None)) assert_slotted(Waiter(qs)) assert_slotted( ExecutionUnit(qs, r, ResultVariable(), {}, Literal(""), None)) assert_slotted(HangUnit(qs, r, {}, None, Resumer())) assert_slotted(RawUnit(qs, r, {}, Resumer())) assert_slotted(FunctionUnit(qs, rs, ResultVariable(), {}, None)) assert_slotted(i) assert_slotted(GradualSetAttributeHelper(sa, i, "A", ResultVariable())) assert_slotted( SetAttributeHelper(qs, rs, ResultVariable(), {}, Literal("A"), sa, i, "A"))
def t_REGEX(t: lex.LexToken) -> lex.LexToken: # noqa: N802 r"/([^/\\]|\\.)+/" value = Reference("self") # anonymous value try: expr = Regex(value, t.value[1:-1]) t.value = expr return t except RegexError as error: end = t.lexer.lexpos - t.lexer.linestart + 1 (s, e) = t.lexer.lexmatch.span() start = end - (e - s) r: Range = Range(t.lexer.inmfile, t.lexer.lineno, start, t.lexer.lineno, end) raise ParserException(r, t.value, "Regex error in %s: '%s'" % (t.value, error))
def create_string_format(format_string, variables, location): """ Create a string interpolation statement """ _vars = [] for var_str in variables: var_parts = var_str[1].split(".") ref = Reference(var_parts[0]) ref.namespace = namespace ref.location = location if len(var_parts) > 1: for attr in var_parts[1:]: ref = AttributeReference(ref, attr) ref.location = location ref.namespace = namespace _vars.append((ref, var_str[0])) else: _vars.append((ref, var_str[0])) return StringFormat(format_string, _vars)
def create_string_format( format_string: LocatableString, variables: List[Tuple[str, LocatableString]]) -> StringFormat: """ Create a string interpolation statement. This function assumes that the variables of a match are on the same line. :param format_string: the LocatableString as it was received by get_string_ast_node() :param variables: A list of tuples where each tuple is a combination of a string and LocatableString The string is the match containing the {{}} (ex: {{a.b}}) and the LocatableString is composed of just the variables and the range for those variables. (ex. LocatableString("a.b", range(a.b), lexpos, namespace)) """ assert namespace _vars = [] for match, var in variables: var_name: str = str(var) var_parts: List[str] = var_name.split(".") start_char = var.location.start_char end_char = start_char + len(var_parts[0]) range: Range = Range(var.location.file, var.location.lnr, start_char, var.location.lnr, end_char) ref_locatable_string = LocatableString(var_parts[0], range, var.lexpos, var.namespace) ref = Reference(ref_locatable_string) ref.namespace = namespace if len(var_parts) > 1: attribute_offsets: Iterator[int] = accumulate( var_parts[1:], lambda acc, part: acc + len(part) + 1, initial=end_char + 1) for attr, char_offset in zip(var_parts[1:], attribute_offsets): range_attr: Range = Range(var.location.file, var.location.lnr, char_offset, var.location.lnr, char_offset + len(attr)) attr_locatable_string: LocatableString = LocatableString( attr, range_attr, var.lexpos, var.namespace) ref = AttributeReference(ref, attr_locatable_string) ref.location = range_attr ref.namespace = namespace _vars.append((ref, match)) else: _vars.append((ref, match)) return StringFormat(str(format_string), _vars)
def p_var_ref_2(p: YaccProduction) -> None: "var_ref : ns_ref %prec NS_REF" p[0] = Reference(p[1]) attach_from_string(p, 1)
def __init__(self, attr: Reference, name: str) -> None: super(IsDefined, self).__init__([attr]) self.attr = attr.root_in_self() self.name = name
def t_REGEX(t): # noqa: N802 r'/[^/]*/' value = Reference("self") # anonymous value expr = Regex(value, t.value[1:-1]) t.value = expr return t
def p_var_ref_2(p): "var_ref : ns_ref" p[0] = Reference(str(p[1])) attach_from_string(p, 1)
def p_condition_is_defined_short(p): """condition : ID IS DEFINED""" p[0] = IsDefined(Reference('self'), p[1]) attach_lnr(p)
def p_local_var(p: YaccProduction) -> None: "local_var : ns_ref" p[0] = Reference(p[1]) attach_from_string(p, 1)