Chords are now parsed with a regular expression: ply is overkill here

* Preparing for parsing of `{define: FOO}` statements
* Brackets can now contain several space-separated chords (as in `[A/A B#]`).

patacrep/data/examples/songs/chords.sgc

@@ -15,3 +15,4 @@
 [A/A]Deux notes
 [F/Fb]Deux notes, bémol
 [B/C#]Deux notes, dièse
+[A/C# Dmaj]Plusieurs accords

patacrep/songs/chordpro/ast.py

@@ -117,19 +117,37 @@ class Space(LineElement):
     def __str__(self):
         return " "
 
-class Chord(LineElement):
-    """A chord."""
-
+class ChordList(LineElement):
+    """A list of chords."""
     _template = "chord"
 
-    def __init__(self, key, alteration, modifier, add_note, bass):
+    def __init__(self, *chords):
+        self.chords = chords
+
+    def __str__(self):
+        return "[{}]".format(" ".join(
+            [str(chord) for chord in self.chords]
+            ))
+
+class Chord:
+    """A chord."""
+
+    def __init__(
+            self,
+            key,
+            alteration=None,
+            modifier=None,
+            addnote=None,
+            basskey=None,
+            bassalteration=None,
+        ):
         # pylint: disable=too-many-arguments
-        super().__init__()
         self.key = key
         self.alteration = alteration
         self.modifier = modifier
-        self.add_note = add_note
-        self.bass = bass
+        self.addnote = addnote
+        self.basskey = basskey
+        self.bassalteration = bassalteration
 
     def __str__(self):
         text = ""
@@ -138,13 +156,13 @@ class Chord(LineElement):
             text += self.alteration
         if self.modifier is not None:
             text += self.modifier
-        if self.add_note is not None:
-            text += str(self.add_note)
-        if self.bass is not None:
-            text += "/" + self.bass[0]
-            if self.bass[1] is not None:
-                text += self.bass[1]
-        return "[{}]".format(text)
+        if self.addnote is not None:
+            text += str(self.addnote)
+        if self.basskey is not None:
+            text += "/" + self.basskey
+            if self.bassalteration is not None:
+                text += self.bassalteration
+        return text
 
 class Verse(AST):
     """A verse (or bridge, or chorus)"""

patacrep/songs/chordpro/data/latex/content_chord.tex

@@ -1,13 +1,16 @@
 \[
-    ((- content.key -))
-    (* if content.alteration == '#' *)#(* endif -*)
-    (* if content.alteration == 'b' *)&(* endif -*)
-    (* if content.modifier *)((content.modifier))(* endif -*)
-    (* if content.add_note *)((content.add_note))(* endif -*)
-    (* if content.bass -*)
-        /
-        ((- content.bass[0] -))
-        (* if content.bass[1] == '#' *)#(* endif -*)
-        (* if content.bass[1] == 'b' *)&(* endif -*)
-    (* endif -*)
+    (*- for chord in content.chords -*)
+        (* if not loop.first *) (* endif *)
+        ((- chord.key -))
+        (* if chord.alteration == '#' *)#(* endif -*)
+        (* if chord.alteration == 'b' *)&(* endif -*)
+        (* if chord.modifier *)((chord.modifier))(* endif -*)
+        (* if chord.add_note *)((chord.add_note))(* endif -*)
+        (* if chord.basskey -*)
+            /
+            ((- chord.basskey -))
+            (* if chord.bassalteration == '#' *)#(* endif -*)
+            (* if chord.bassalteration == 'b' *)&(* endif -*)
+        (* endif -*)
+    (* endfor -*)
 ]

patacrep/songs/chordpro/lexer.py

@@ -9,15 +9,11 @@ LOGGER = logging.getLogger()
 tokens = (
     'LBRACE',
     'RBRACE',
-    'KEY',
-    'ALTERATION',
-    'MODIFIER',
-    'ADDNOTE',
-    'SLASH',
     'NEWLINE',
     'COLON',
     'WORD',
     'SPACE',
+    'CHORD',
     'TEXT',
     'KEYWORD',
     'SOC',
@@ -43,11 +39,7 @@ class ChordProLexer:
 
     t_SPACE = r'[ \t]+'
 
-    t_chord_KEY = r'[A-G]'
-    t_chord_ALTERATION = r'[#b]'
-    t_chord_MODIFIER = r'(maj|dim|m|sus)'
-    t_chord_ADDNOTE = r'[2-9]'
-    t_chord_SLASH = r'/'
+    t_chord_CHORD = r'[A-G#bmajdisus2-9/ ]+'
 
     t_directive_SPACE = r'[ \t]+'
     t_directive_KEYWORD = r'[a-zA-Z_]+'

patacrep/songs/chordpro/syntax.py

@@ -2,6 +2,7 @@
 
 import logging
 import ply.yacc as yacc
+import re
 
 from patacrep.songs.syntax import Parser
 from patacrep.songs.chordpro import ast
@@ -9,6 +10,32 @@ from patacrep.songs.chordpro.lexer import tokens, ChordProLexer
 
 LOGGER = logging.getLogger()
 
+CHORD_RE = re.compile(
+    r"""
+        (?P<key>[A-G])
+        (?P<alteration>[b#])?
+        (?P<modifier>(maj|sus|dim|m))?
+        (?P<addnote>[2-9])?
+        (
+            /
+            (?P<basskey>[A-G])
+            (?P<bassalteration>[b#])?
+        )?
+    """,
+    re.VERBOSE
+    )
+
+def _parse_chords(string):
+    """Parse a list of chords.
+
+    Iterate over :class:`ast.Chord` objects.
+    """
+    for chord in string.split():
+        match = CHORD_RE.match(chord)
+        if match is None:
+            TODO
+        yield ast.Chord(**match.groupdict())
+
 class ChordproParser(Parser):
     """ChordPro parser class"""
     # pylint: disable=too-many-public-methods
@@ -108,48 +135,8 @@ class ChordproParser(Parser):
 
     @staticmethod
     def p_chord(symbols):
-        """chord : KEY chordalteration chordmodifier chordaddnote chordbass"""
-        symbols[0] = ast.Chord(
-            symbols[1],
-            symbols[2],
-            symbols[3],
-            symbols[4],
-            symbols[5],
-            )
-
-    @staticmethod
-    def p_chordalteration(symbols):
-        """chordalteration : ALTERATION
-                           | empty
-        """
-        symbols[0] = symbols[1]
-
-    @staticmethod
-    def p_chordmodifier(symbols):
-        """chordmodifier : MODIFIER
-                         | empty
-        """
-        symbols[0] = symbols[1]
-
-    @staticmethod
-    def p_chordaddnote(symbols):
-        """chordaddnote : ADDNOTE
-                        | empty
-        """
-        if symbols[1] is None:
-            symbols[0] = symbols[1]
-        else:
-            symbols[0] = int(symbols[1])
-
-    @staticmethod
-    def p_chordbass(symbols):
-        """chordbass : SLASH KEY chordalteration
-                        | empty
-        """
-        if len(symbols) == 2:
-            symbols[0] = None
-        else:
-            symbols[0] = (symbols[2], symbols[3])
+        """chord : CHORD"""
+        symbols[0] = ast.ChordList(*_parse_chords(symbols[1]))
 
     @staticmethod
     def p_chorus(symbols):

patacrep/songs/chordpro/test/chords.sgc

@@ -10,3 +10,4 @@
 [A/A]Deux notes
 [F/Fb]Deux notes, bémol
 [B/C#]Deux notes, dièse
+[Ab B#/A]Plusieurs notes à la suite

patacrep/songs/chordpro/test/chords.txt

@@ -12,4 +12,5 @@
   [A/A]Deux notes
   [F/Fb]Deux notes, bémol
   [B/C#]Deux notes, dièse
+  [Ab B#/A]Plusieurs notes à la suite
 {end_of_verse}