コード例 #1
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "exception":
            if string:
                self.first_formatting = [Node.from_fst({"type": "space", "value": " "}, on_attribute=on_attribute, parent=parent)]
                return Node.from_fst(baron.parse("try: pass\nexcept %s: pass" % string)[0]["excepts"][0]["exception"], parent=parent, on_attribute=on_attribute)
            else:
                self.first_formatting = []
                self.delimiter = ""
                self.target = ""
                return ""

        elif on_attribute == "target":
            if not self.exception:
                raise Exception("Can't set a target to an exception node that doesn't have an exception set")

            if string:
                self.delimiter = "as"
                self.second_formatting = [Node.from_fst({"type": "space", "value": " "}, on_attribute=on_attribute, parent=parent)]
                self.third_formatting = [Node.from_fst({"type": "space", "value": " "}, on_attribute=on_attribute, parent=parent)]
                return Node.from_fst(baron.parse("try: pass\nexcept a as %s: pass" % string)[0]["excepts"][0]["target"], parent=parent, on_attribute=on_attribute)

            else:
                self.delimiter = ""
                self.second_formatting = []
                self.third_formatting = []
                return ""

        else:
            raise Exception("Unhandled case")
コード例 #2
0
    def _parse_indented(self, value, replace=False):
        if replace:
            implicit_indent = self.indentation + self.default_indent
        else:
            implicit_indent = self.el_indentation
        value = indent_str(value, implicit_indent)
        # First line is on the same line with def/class element
        # we do not want to the el_indentation there
        # e.g def f(): {value}
        if value.startswith(" ") and value.lstrip(" ").startswith("\n"):
            leading_endl = ""
            value = value[len(implicit_indent):]
        else:
            leading_endl = "\n"

        # Handle the case of empty lines
        if strip_comments(value.strip(" \n")):
            fst = baron.parse("while a:%s%s" % (leading_endl, value))
            trailing_endl = fst[1:]
            fst = fst[0]['value']
            if leading_endl:
                fst[0] = {"type": "space", "value": fst[0]['indent']}
            fst += trailing_endl
        else:
            fst = baron.parse(value)

        return fst
コード例 #3
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node_list(self, string, parent, on_attribute):
        fst = baron.parse("(%s)" % string)[0]["value"]

        # I assume that I've got an AssociativeParenthesisNode here instead of a tuple
        # because string is only one single element
        if not isinstance(fst, list):
            fst = baron.parse("(%s,)" % string)[0]["value"]

        return NodeList.from_fst(fst, parent=parent, on_attribute=on_attribute)
コード例 #4
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "iterator":
            return Node.from_fst(baron.parse("[x for %s in x]" % string)[0]["generators"][0]["iterator"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "target":
            return Node.from_fst(baron.parse("[x for s in %s]" % string)[0]["generators"][0]["target"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #5
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "value":
            return Node.from_fst(baron.parse("def a(b=%s): pass" % string)[0]["arguments"][0]["value"], parent=parent, on_attribute=on_attribute) if string else ""

        elif on_attribute == "target":
            return Node.from_fst(baron.parse("def a(%s=b): pass" % string)[0]["arguments"][0]["target"], parent=parent, on_attribute=on_attribute) if string else ""

        else:
            raise Exception("Unhandled case")
コード例 #6
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "first":
            return Node.from_fst(baron.parse("%s and b" % string)[0]["first"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "second":
            return Node.from_fst(baron.parse("bb and %s" % string)[0]["second"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #7
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "target":
            return Node.from_fst(baron.parse("%s = a" % string)[0]["target"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "value":
            return Node.from_fst(baron.parse("a = %s" % string)[0]["value"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #8
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "value":
            return Node.from_fst(baron.parse("{a: %s}" % string)[0]["value"][0]["value"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "key":
            return Node.from_fst(baron.parse("{%s: a}" % string)[0]["value"][0]["key"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #9
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "target":
            return Node.from_fst(baron.parse("for i in %s: pass" % string)[0]["target"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "iterator":
            return Node.from_fst(baron.parse("for %s in i: pass" % string)[0]["iterator"], parent=parent, on_attribute=on_attribute)

        else:
            return super(ForNode, self)._string_to_node(string, parent, on_attribute)
コード例 #10
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "value":
            return Node.from_fst(baron.parse("@%s()\ndef a(): pass" % string)[0]["decorators"][0]["value"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "call":
            if string:
                return Node.from_fst(baron.parse("@a%s\ndef a(): pass" % string)[0]["decorators"][0]["call"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #11
0
ファイル: test_baron.py プロジェクト: PyCQA/baron
def test_error_bad_indentation():
    """ Regression test case

    It shows a discrepency between python2 and python3 in string
    comparisons with None.
    """
    with pytest.raises(ParsingError):
        parse("def fun():\nass")
    with pytest.raises(BaronError):
        parse("def fun():\nass")
コード例 #12
0
    def value(self, value):
        fst = baron.parse("(%s)" % value)[0]["value"]

        # I assume that I've got an AssociativeParenthesisNode here instead
        # of a tuple because string is only one single element
        if not isinstance(fst, list):
            assert fst["type"] == "associativeparenthesis"
            fst = baron.parse("(%s,)" % value)[0]["value"]

        return fst
コード例 #13
0
def test_error_bad_indentation():
    """ Regression test case

    It shows a discrepency between python2 and python3 in string
    comparisons with None.
    """
    with pytest.raises(ParsingError):
        parse("def fun():\nass")
    with pytest.raises(BaronError):
        parse("def fun():\nass")
コード例 #14
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node_list(self, string, parent, on_attribute):
        if on_attribute == "targets":
            fst = baron.parse("from a import %s" % string)[0]["targets"]
            return NodeList.from_fst(fst, parent=parent, on_attribute=on_attribute)

        if on_attribute == "value":
            fst = baron.parse("from %s import s" % string)[0]["value"]
            return NodeList.from_fst(fst, parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #15
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "value":
            return Node.from_fst(baron.parse("assert %s" % string)[0]["value"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "message":
            if string:
                self.third_formatting = [Node.from_fst({"type": "space", "value": " "}, on_attribute=on_attribute, parent=parent)]
                return Node.from_fst(baron.parse("assert plop, %s" % string)[0]["message"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #16
0
 def _parse_inline(self, value):
     if value.rstrip("\n").count("\n"):
         raise ValueError("inline code can't have multiple lines")
     if strip_comments(value.strip(" \n")):
         fst = baron.parse("while a: %s" % value)[0]
         indent = fst['third_formatting'][0]['value'][1:]
     else:
         fst = {"value": [baron.parse(value)[0]]}
         indent = fst['formatting'][0]['value'] if value.startswith(
             " ") else ""
     fst['value'].insert(0, {"type": "space", "value": indent})
     return fst["value"]
コード例 #17
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node_list(self, string, parent, on_attribute):
        if on_attribute != "excepts":
            return super(TryNode, self)._string_to_node_list(string, parent=parent, on_attribute=on_attribute)

        clean_string = re.sub("^ *\n", "", string) if "\n" in string else string
        indentation = len(re.search("^ *", clean_string).group())

        if indentation:
            string = "\n".join(map(lambda x: x[indentation:], string.split("\n")))

        string = string.rstrip()
        string += "\n"

        if self.next and self.on_attribute == "root":
            string += "\n\n"
        elif self.next:
            string += "\n"

        result = NodeList.from_fst(baron.parse("try:\n pass\n%sfinally:\n pass" % string)[0]["excepts"], parent=parent, on_attribute=on_attribute)

        if self.indentation:
            result.increase_indentation(len(self.indentation))
            if self._get_last_member_to_clean().type != "except":
                # assume that this is an endl node, this might break
                result[-1].value.node_list[-1].indent = self.indentation
            elif self.next:
                result[-1].value.node_list[-1].indent = self.indentation

        return result
コード例 #18
0
    def __init__(self, source_code):
        self.first_blank_lines = []  # XXX might need changes

        if isinstance(source_code, string_instance):
            self.node_list = base_nodes.NodeList.from_fst(
                baron.parse(source_code), parent=self, on_attribute="root")
            self.middle_separator = nodes.DotNode({
                "type": "endl",
                "formatting": [],
                "value": "\n",
                "indent": ""
            })

            self.data = []
            previous = None
            for i in self.node_list:
                if i.type != "endl":
                    self.data.append([i, []])
                elif previous and previous.type == "endl":
                    self.data.append([previous, []])
                elif previous is None and i.type == "endl":
                    self.data.append([i, []])
                elif self.data:
                    self.data[-1][1].append(i)

                previous = i
            self.node_list.parent = None
        else:
            # Might be init from same object, or slice
            super(RedBaron, self).__init__(source_code)
        self.on_attribute = None
        self.parent = None
コード例 #19
0
ファイル: redbaron.py プロジェクト: PyCQA/redbaron
    def __init__(self, source_code):
        self.first_blank_lines = []  # XXX might need changes

        if isinstance(source_code, string_instance):
            self.node_list = base_nodes.NodeList.from_fst(baron.parse(source_code), parent=self, on_attribute="root")
            self.middle_separator = nodes.DotNode({"type": "endl", "formatting": [], "value": "\n", "indent": ""})

            self.data = []
            previous = None
            for i in self.node_list:
                if i.type != "endl":
                    self.data.append([i, []])
                elif previous and previous.type == "endl":
                    self.data.append([previous, []])
                elif previous is None and i.type == "endl":
                    self.data.append([i, []])
                elif self.data:
                    self.data[-1][1].append(i)

                previous = i
            self.node_list.parent = None
        else:
            # Might be init from same object, or slice
            super(RedBaron, self).__init__(source_code)
        self.on_attribute = None
        self.parent = None
コード例 #20
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node_list(self, string, parent, on_attribute):
        if on_attribute == "generators":
            fst = baron.parse("{x %s}" % string)[0]["generators"]
            return NodeList.from_fst(fst, parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #21
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node_list(self, string, parent, on_attribute):
        if on_attribute != "value":
            return super(IfelseblockNode, self)._string_to_node_list(string, parent=parent, on_attribute=on_attribute)

        string = string.rstrip()
        string += "\n"

        if self.next and self.on_attribute == "root":
            string += "\n\n"
        elif self.next:
            string += "\n"

        clean_string = re.sub("^ *\n", "", string) if "\n" in string else string
        indentation = len(re.search("^ *", clean_string).group())

        if indentation:
            string = "\n".join(map(lambda x: x[indentation:], string.split("\n")))

        result = NodeList.from_fst(baron.parse(string)[0]["value"], parent=parent, on_attribute=on_attribute)

        if self.indentation:
            result.increase_indentation(len(self.indentation))
            if self.next:
                result[-1].value.node_list[-1].indent = self.indentation

        return result
コード例 #22
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "value":
            return Node.from_fst(baron.parse("with %s: pass" % string)[0]["contexts"][0]["value"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "as":
            if string:
                self.first_formatting = [{"type": "space", "value": " "}]
                self.second_formatting = [{"type": "space", "value": " "}]
                return Node.from_fst(baron.parse("with a as %s: pass" % string)[0]["contexts"][0]["as"], parent=parent, on_attribute=on_attribute)
            else:
                self.first_formatting = []
                self.second_formatting = []
                return ""

        else:
            raise Exception("Unhandled case")
コード例 #23
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "lower":
            if string:
                return Node.from_fst(baron.parse("a[%s:]" % string)[0]["value"][1]["value"]["lower"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "upper":
            if string:
                return Node.from_fst(baron.parse("a[:%s]" % string)[0]["value"][1]["value"]["upper"], parent=parent, on_attribute=on_attribute)

        elif on_attribute == "step":
            self.has_two_colons = bool(string)
            if string:
                return Node.from_fst(baron.parse("a[::%s]" % string)[0]["value"][1]["value"]["step"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #24
0
    def locals(self, value):
        if not value:
            return None

        if not self.globals:
            raise Exception("I can't set locals when globals aren't set.")
        return baron.parse("exec a in b, %s" % value)[0]["locals"]
コード例 #25
0
 def generic_from_str(source_code: str, parent=None, on_attribute=None):
     assert isinstance(source_code, str)
     fst = baron.parse(source_code)
     assert len(fst) == 1
     return Node.generic_from_fst(fst[0],
                                  parent=parent,
                                  on_attribute=on_attribute)
コード例 #26
0
ファイル: test_render.py プロジェクト: Astalaseven/baron
def test_walk_assignment():
    node = parse("a = 1")
    walker = RenderWalkerTester([
    ('>', 'node', 'assignment', 0, False),
        ('>', 'key', 'name', 'target', False),
            ('>', 'constant', 'a', 'value', False),
            ('<', 'constant', 'a', 'value', False),
        ('<', 'key', 'name', 'target', False),
        ('>', 'formatting', 'list', 'first_formatting', False),
            ('>', 'node', 'space', 0, False),
                ('>', 'constant', ' ', 'value', False),
                ('<', 'constant', ' ', 'value', False),
            ('<', 'node', 'space', 0, False),
        ('<', 'formatting', 'list', 'first_formatting', False),
        ('>', 'constant', '=', '=', False),
        ('<', 'constant', '=', '=', False),
        ('>', 'formatting', 'list', 'second_formatting', False),
            ('>', 'node', 'space', 0, False),
                ('>', 'constant', ' ', 'value', False),
                ('<', 'constant', ' ', 'value', False),
            ('<', 'node', 'space', 0, False),
        ('<', 'formatting', 'list', 'second_formatting', False),
        ('>', 'key', 'int', 'value', False),
            ('>', 'constant', '1', 'value', False),
            ('<', 'constant', '1', 'value', False),
        ('<', 'key', 'int', 'value', False),
    ('<', 'node', 'assignment', 0, False),
    ])

    walker.walk(node)
コード例 #27
0
ファイル: test_tokenizer.py プロジェクト: asterbini/baron
def test_floating_point_parser_bug_85():
    from baron import parse
    assert parse('d*e-1') == [{
        'first': {
            'first': {
                'type': 'name',
                'value': 'd'
            },
            'first_formatting': [],
            'second': {
                'type': 'name',
                'value': 'e'
            },
            'second_formatting': [],
            'type': 'binary_operator',
            'value': '*'
        },
        'first_formatting': [],
        'second': {
            'section': 'number',
            'type': 'int',
            'value': '1'
        },
        'second_formatting': [],
        'type': 'binary_operator',
        'value': '-'
    }]
コード例 #28
0
ファイル: test_render.py プロジェクト: wavenator/baron
def test_walk_assignment():
    node = parse("a = 1")
    walker = RenderWalkerTester([
    ('>', 'node', 'assignment', 0, False),
        ('>', 'key', 'name', 'target', False),
            ('>', 'string', 'a', 'value', False),
            ('<', 'string', 'a', 'value', False),
        ('<', 'key', 'name', 'target', False),
        ('>', 'formatting', 'list', 'first_formatting', False),
            ('>', 'node', 'space', 0, False),
                ('>', 'string', ' ', 'value', False),
                ('<', 'string', ' ', 'value', False),
            ('<', 'node', 'space', 0, False),
        ('<', 'formatting', 'list', 'first_formatting', False),
        ('>', 'constant', '=', '=', False),
        ('<', 'constant', '=', '=', False),
        ('>', 'formatting', 'list', 'second_formatting', False),
            ('>', 'node', 'space', 0, False),
                ('>', 'string', ' ', 'value', False),
                ('<', 'string', ' ', 'value', False),
            ('<', 'node', 'space', 0, False),
        ('<', 'formatting', 'list', 'second_formatting', False),
        ('>', 'key', 'int', 'value', False),
            ('>', 'string', '1', 'value', False),
            ('<', 'string', '1', 'value', False),
        ('<', 'key', 'int', 'value', False),
    ('<', 'node', 'assignment', 0, False),
    ])

    walker.walk(node)
コード例 #29
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node_list(self, string, parent, on_attribute):
        if on_attribute == "arguments":
            self.first_formatting = [{"type": "space", "value": " "}] if string else []
            fst = baron.parse("lambda %s: x" % string)[0]["arguments"]
            return NodeList.from_fst(fst, parent=parent, on_attribute=on_attribute)

        else:
            return super(DefNode, self)._string_to_node_list(string, parent, on_attribute)
コード例 #30
0
 def value(self, value):
     if not value:
         raise ValueError("print call cannot be empty")
     if value.lstrip(" ")[0] != "(":
         raise ValueError("print call must start with (")
     if value.rstrip(" ")[-1] != ")":
         raise ValueError("print call must end with )")
     return baron.parse("print%s" % value)[0]["value"]
コード例 #31
0
ファイル: nodes.py プロジェクト: brycepg/redbaron-fork
    def _string_to_node(self, string, parent, on_attribute):
        if on_attribute == "value":
            self.formatting = [{"type": "space", "value": " "}] if string else []
            if string:
                return Node.from_fst(baron.parse("return %s" % string)[0]["value"], parent=parent, on_attribute=on_attribute)

        else:
            raise Exception("Unhandled case")
コード例 #32
0
    def target(self, value):
        if not self.exception:
            raise Exception("Can't set a target to an exception node "
                            "that doesn't have an exception set")

        if value == "":
            return None

        code = "try: pass\nexcept a as %s: pass" % value
        return baron.parse(code)[0]["excepts"][0]["target"]
コード例 #33
0
def test_comment_before_for():
    code = """
for var in iter:
    pass

# comment
for var in iter:
    pass
"""
    assert dumps(parse(code)) == code
コード例 #34
0
ファイル: test_render.py プロジェクト: Astalaseven/baron
def test_walk_stop():
    node = parse("a = 1")
    walker = RenderWalkerTester([
    ('>', 'node', 'assignment', 0, False),
        ('>', 'key', 'name', 'target', False),
            ('>', 'constant', 'a', 'value', True),
        ('<', 'key', 'name', 'target', False),
    ('<', 'node', 'assignment', 0, False),
    ])

    walker.walk(node)
コード例 #35
0
ファイル: test_baron.py プロジェクト: lensvol/baron
def test_missing_quote_yields_error():
    with pytest.raises(UntreatedError):
        parse("'")
    with pytest.raises(UntreatedError):
        parse("'\n")
    with pytest.raises(UntreatedError):
        parse("'\n")
コード例 #36
0
ファイル: test_tokenizer.py プロジェクト: PyCQA/baron
def test_floating_point_parser_bug_85():
    from baron import parse
    assert parse('d*e-1') == [
        {'first': {'first': {'type': 'name', 'value': 'd'},
                   'first_formatting': [],
                   'second': {'type': 'name', 'value': 'e'},
                   'second_formatting': [],
                   'type': 'binary_operator',
                   'value': '*'},
         'first_formatting': [],
         'second': {'section': 'number', 'type': 'int', 'value': '1'},
         'second_formatting': [],
         'type': 'binary_operator',
         'value': '-'}]
コード例 #37
0
ファイル: test_baron.py プロジェクト: pombreda/baron
def test_error_unexpected_formatting():
    with pytest.raises(UnExpectedFormattingToken):
        parse("   a\nb")
コード例 #38
0
def test_fst():
    some_code = "ax + (z * 4)"
    red = RedBaron(some_code)
    assert baron.parse(some_code) == red.fst()
コード例 #39
0
ファイル: pyfmt.py プロジェクト: Psycojoker/pyfmt
def format_code(source_code):
    return Dumper().dump_root(baron.parse(source_code))
コード例 #40
0
ファイル: test_baron.py プロジェクト: pombreda/baron
def test_dummy_parse():
    parse("pouet")
コード例 #41
0
ファイル: test_baron.py プロジェクト: PyCQA/baron
def test_error_unexpected_formatting():
    with pytest.raises(ParsingError):
        parse("   a\nb")
    with pytest.raises(BaronError):
        parse("   a\nb")
コード例 #42
0
ファイル: test_baron.py プロジェクト: pombreda/baron
def test_error_parsing_error():
    with pytest.raises(ParsingError):
        parse("(")
コード例 #43
0
ファイル: test_render.py プロジェクト: Astalaseven/baron
def test_walk_funcdef_with_leading_space():
    node = parse("""\

@deco
def fun(arg1):
    pass
""")
    walker = RenderWalkerTester([
    ('>', 'node', 'endl', 0, False),
        ('>', 'formatting', 'list', 'formatting', False),
        ('<', 'formatting', 'list', 'formatting', False),
        ('>', 'constant', '\n', 'value', False),
        ('<', 'constant', '\n', 'value', False),
        ('>', 'constant', '', 'indent', False),
        ('<', 'constant', '', 'indent', False),
    ('<', 'node', 'endl', 0, False),
    ('>', 'node', 'funcdef', 1, False),
        ('>', 'list', 'list', 'decorators', False),
            ('>', 'node', 'decorator', 0, False),
                ('>', 'constant', '@', '@', False),
                ('<', 'constant', '@', '@', False),
                ('>', 'key', 'dotted_name', 'value', False),
                    ('>', 'list', 'list', 'value', False),
                        ('>', 'node', 'name', 0, False),
                            ('>', 'constant', 'deco', 'value', False),
                            ('<', 'constant', 'deco', 'value', False),
                        ('<', 'node', 'name', 0, False),
                    ('<', 'list', 'list', 'value', False),
                ('<', 'key', 'dotted_name', 'value', False),
            ('<', 'node', 'decorator', 0, False),
            ('>', 'node', 'endl', 1, False),
                ('>', 'formatting', 'list', 'formatting', False),
                ('<', 'formatting', 'list', 'formatting', False),
                ('>', 'constant', '\n', 'value', False),
                ('<', 'constant', '\n', 'value', False),
                ('>', 'constant', '', 'indent', False),
                ('<', 'constant', '', 'indent', False),
            ('<', 'node', 'endl', 1, False),
        ('<', 'list', 'list', 'decorators', False),
        ('>', 'constant', 'def', 'def', False),
        ('<', 'constant', 'def', 'def', False),
        ('>', 'formatting', 'list', 'first_formatting', False),
            ('>', 'node', 'space', 0, False),
                ('>', 'constant', ' ', 'value', False),
                ('<', 'constant', ' ', 'value', False),
            ('<', 'node', 'space', 0, False),
        ('<', 'formatting', 'list', 'first_formatting', False),
        ('>', 'constant', 'fun', 'name', False),
        ('<', 'constant', 'fun', 'name', False),
        ('>', 'formatting', 'list', 'second_formatting', False),
        ('<', 'formatting', 'list', 'second_formatting', False),
        ('>', 'constant', '(', '(', False),
        ('<', 'constant', '(', '(', False),
        ('>', 'formatting', 'list', 'third_formatting', False),
        ('<', 'formatting', 'list', 'third_formatting', False),
        ('>', 'list', 'list', 'arguments', False),
            ('>', 'node', 'def_argument', 0, False),
                ('>', 'constant', 'arg1', 'name', False),
                ('<', 'constant', 'arg1', 'name', False),
            ('<', 'node', 'def_argument', 0, False),
        ('<', 'list', 'list', 'arguments', False),
        ('>', 'formatting', 'list', 'fourth_formatting', False),
        ('<', 'formatting', 'list', 'fourth_formatting', False),
        ('>', 'constant', ')', ')', False),
        ('<', 'constant', ')', ')', False),
        ('>', 'formatting', 'list', 'fifth_formatting', False),
        ('<', 'formatting', 'list', 'fifth_formatting', False),
        ('>', 'constant', ':', ':', False),
        ('<', 'constant', ':', ':', False),
        ('>', 'formatting', 'list', 'sixth_formatting', False),
        ('<', 'formatting', 'list', 'sixth_formatting', False),
        ('>', 'list', 'list', 'value', False),
            ('>', 'node', 'endl', 0, False),
                ('>', 'formatting', 'list', 'formatting', False),
                ('<', 'formatting', 'list', 'formatting', False),
                ('>', 'constant', '\n', 'value', False),
                ('<', 'constant', '\n', 'value', False),
                ('>', 'constant', '    ', 'indent', False),
                ('<', 'constant', '    ', 'indent', False),
            ('<', 'node', 'endl', 0, False),
            ('>', 'node', 'pass', 1, False),
                ('>', 'constant', 'pass', 'type', False),
                ('<', 'constant', 'pass', 'type', False),
            ('<', 'node', 'pass', 1, False),
            ('>', 'node', 'endl', 2, False),
                ('>', 'formatting', 'list', 'formatting', False),
                ('<', 'formatting', 'list', 'formatting', False),
                ('>', 'constant', '\n', 'value', False),
                ('<', 'constant', '\n', 'value', False),
                ('>', 'constant', '', 'indent', False),
                ('<', 'constant', '', 'indent', False),
            ('<', 'node', 'endl', 2, False),
        ('<', 'list', 'list', 'value', False),
    ('<', 'node', 'funcdef', 1, False),
    ])

    walker.walk(node)
コード例 #44
0
ファイル: test_baron.py プロジェクト: pombreda/baron
def test_error_grouping():
    with pytest.raises(GroupingError):
        parse("   (a\n b")
コード例 #45
0
ファイル: test_baron.py プロジェクト: pombreda/baron
def test_error_untreated_error():
    with pytest.raises(UntreatedError):
        parse("?")
コード例 #46
0
ファイル: redbaron.py プロジェクト: acieroid/redbaron
 def __init__(self, source_code):
     self.data = map(to_node, baron.parse(source_code))
コード例 #47
0
ファイル: test_pyfmt.py プロジェクト: Psycojoker/pyfmt
def test_find_endl_functionnal():
    assert find('endl', baron.parse("[a, b, c]")[0]["value"]) == None
    assert find('endl', baron.parse("[a, b,\n c]")[0]["value"]) == {'formatting': [], 'indent': ' ', 'type': 'endl', 'value': '\n'}