Esempio n. 1
0
        def definition(correct, correct_start, path):
            should_be = set()
            for match in re.finditer('(?:[^ ]+)', correct):
                string = match.group(0)
                parser = grammar36.parse(string,
                                         start_symbol='eval_input',
                                         error_recovery=False)
                parser_utils.move(parser.get_root_node(), self.line_nr)
                element = parser.get_root_node()
                module_context = script._get_module()
                # The context shouldn't matter for the test results.
                user_context = get_user_scope(module_context,
                                              (self.line_nr, 0))
                if user_context.api_type == 'function':
                    user_context = user_context.get_function_execution()
                element.parent = user_context.tree_node
                results = evaluator.eval_element(user_context, element)
                if not results:
                    raise Exception('Could not resolve %s on line %s' %
                                    (match.string, self.line_nr - 1))

                should_be |= set(
                    Definition(evaluator, r.name) for r in results)
            debug.dbg('Finished getting types', color='YELLOW')

            # Because the objects have different ids, `repr`, then compare.
            should = set(comparison(r) for r in should_be)
            return should
Esempio n. 2
0
        def definition(correct, correct_start, path):
            should_be = set()
            for match in re.finditer('(?:[^ ]+)', correct):
                string = match.group(0)
                parser = grammar36.parse(string,
                                         start_symbol='eval_input',
                                         error_recovery=False)
                parser_utils.move(parser.get_root_node(), self.line_nr)
                node = parser.get_root_node()
                module_context = script._get_module_context()
                user_context = get_user_context(module_context,
                                                (self.line_nr, 0))
                node.parent = user_context.tree_node
                results = convert_values(user_context.infer_node(node))
                if not results:
                    raise Exception('Could not resolve %s on line %s' %
                                    (match.string, self.line_nr - 1))

                should_be |= set(
                    Definition(inference_state, r.name) for r in results)
            debug.dbg('Finished getting types', color='YELLOW')

            # Because the objects have different ids, `repr`, then compare.
            should = set(comparison(r) for r in should_be)
            return should
Esempio n. 3
0
        def definition(correct, correct_start, path):
            should_be = set()
            for match in re.finditer('(?:[^ ]+)', correct):
                string = match.group(0)
                parser = Parser(load_grammar(),
                                string,
                                start_symbol='eval_input')
                parser.position_modifier.line = self.line_nr
                element = parser.get_parsed_node()
                element.parent = jedi.api.completion.get_user_scope(
                    script._get_module(), (self.line_nr, self.column))
                results = evaluator.eval_element(element)
                if not results:
                    raise Exception('Could not resolve %s on line %s' %
                                    (match.string, self.line_nr - 1))

                should_be |= set(Definition(evaluator, r) for r in results)

            # Because the objects have different ids, `repr`, then compare.
            should = set(comparison(r) for r in should_be)
            return should