Simplified dual dialog design.

Forgot to add tests earlier. Here they are too!

2 files changed, 133 insertions, 27 deletions

diff --git a/screenplain/parse.py b/screenplain/parse.py
index 3f19662..336b4eb 100644
--- a/screenplain/parse.py
+++ b/screenplain/parse.py
@@ -42,36 +42,17 @@ class Dialog(object):
 
     def __init__(self, lines):
         self.character = lines[0]
-        self.secondary_character = None
-        self.dual = False
         self.blocks = []  # list of tuples of (is_parenthetical, text)
-        self.secondary_blocks = []  # for the second speaker if dual
         self._parse(lines[1:])
 
     def _parse(self, lines):
-        append = self.blocks.append
         inside_parenthesis = False
-        it = iter(lines)
-        while True:
-            try:
-                line = it.next()
-            except StopIteration:
-                return
-            if line == '||' and not self.dual:
-                self.dual = True
-                append = self.secondary_blocks.append
-                try:
-                    self.secondary_character = it.next()
-                    # what if this doesn't look like a character name?
-                except StopIteration:
-                    append(line)  # keep trailing '||'
-                    return
-            else:
-                if line.startswith('('):
-                    inside_parenthesis = True
-                append((inside_parenthesis, line))
-                if line.endswith(')'):
-                    inside_parenthesis = False
+        for line in lines:
+            if line.startswith('('):
+                inside_parenthesis = True
+            self.blocks.append((inside_parenthesis, line))
+            if line.endswith(')'):
+                inside_parenthesis = False
 
     def format(self):
         yield self.indent_character + self.character
@@ -94,6 +75,11 @@ class Dialog(object):
             for line in lines:
                 yield line
 
+class DualDialog(object):
+    def __init__(self, left_lines, right_lines):
+        self.left = Dialog(left_lines)
+        self.right = Dialog(right_lines)
+
 class Action(object):
     indent = ''
     fill = 68
@@ -127,14 +113,23 @@ def is_slug(blanks_before, string):
     upper = string.upper()
     return any(upper.startswith(s) for s in slug_prefixes)
 
+def _create_dialog(line_list):
+    try:
+        dual_index = line_list.index('||')
+    except ValueError:
+        return Dialog(line_list)
+    else:
+        return DualDialog(line_list[:dual_index], line_list[dual_index + 1:])
+
 def create_paragraph(blanks_before, line_list):
     if is_slug(blanks_before, line_list[0]):
         return Slug(line_list)
     if (
         len(line_list) > 1 and
         line_list[0].isupper() and
-        not line_list[0].endswith(TWOSPACE)):
-        return Dialog(line_list)
+        not line_list[0].endswith(TWOSPACE)
+    ):
+        return _create_dialog(line_list)
     elif len(line_list) == 1 and line_list[0].endswith(':'):
         # Not according to spec, see my comment
         #http://prolost.com/blog/2011/8/9/screenplay-markdown.html?lastPage=true#comment14865294
diff --git a/tests/parse_test.py b/tests/parse_test.py
new file mode 100644
index 0000000..75d762a
--- /dev/null
+++ b/tests/parse_test.py
@@ -0,0 +1,111 @@
+import unittest2
+from screenplain import parse
+from screenplain.parse import Slug, Action, Dialog, DualDialog, Transition
+
+class ParseTests(unittest2.TestCase):
+
+    # Without this, the @skip decorator gives
+    # AttributeError: 'ParseTests' object has no attribute '__name__'
+    __name__ = 'ParseTests'
+
+    # A Scene Heading, or "slugline," is any line that has a blank
+    # line following it, and either begins with INT or EXT, or has
+    # two empty lines preceding it. A Scene Heading always has at
+    # least one blank line preceding it.
+    # NOTE: Actually the list used in Appendix 1
+    def test_slug_with_prefix(self):
+        paras = list(parse.parse([
+            'INT. SOMEWHERE - DAY',
+            '',
+            'THIS IS JUST ACTION',
+        ]))
+        self.assertEquals([Slug, Action], [type(p) for p in paras])
+
+    def test_action_is_not_a_slug(self):
+        paras = list(parse.parse([
+            '',
+            'THIS IS JUST ACTION',
+        ]))
+        self.assertEquals([Action], [type(p) for p in paras])
+
+    def test_two_lines_creates_a_slug(self):
+        types = [type(p) for p in parse.parse([
+            '',
+            '',
+            'This is a slug',
+            '',
+        ])]
+        self.assertEquals([Slug], types)
+
+    # A Character element is any line entirely in caps, with one empty
+    # line before it and without an empty line after it.
+    def test_all_caps_is_character(self):
+        paras = [p for p in parse.parse([
+            'SOME GUY',
+            'Hello',
+        ])]
+        self.assertEquals(1, len(paras))
+        dialog = paras[0]
+        self.assertEquals(Dialog, type(dialog))
+        self.assertEquals('SOME GUY', dialog.character)
+
+    # SPMD would not be able to support a character named "23". We
+    # might need a syntax to force a character element.
+    def test_nonalpha_character(self):
+        paras = list(parse.parse([
+            '23',
+            'Hello',
+        ]))
+        self.assertEquals([Action], [type(p) for p in paras])
+
+    # See
+    # http://prolost.com/storage/downloads/spmd/SPMD_proposal.html#section-br
+    def test_twospaced_line_is_not_character(self):
+        paras = list(parse.parse([
+            'SCANNING THE AISLES...  ',
+            'Where is that pit boss?',
+        ]))
+        self.assertEquals([Action], [type(p) for p in paras])
+
+    def test_simple_parenthetical(self):
+        paras = list(parse.parse([
+            'STEEL',
+            '(starting the engine)',
+            'So much for retirement!',
+        ]))
+        self.assertEquals(1, len(paras))
+        dialog = paras[0]
+        self.assertEqual(2, len(dialog.blocks))
+        self.assertEqual((True, '(starting the engine)'), dialog.blocks[0])
+        self.assertEqual((False, 'So much for retirement!'), dialog.blocks[1])
+
+    def test_dual_dialog(self):
+        paras = list(parse.parse([
+            'BRICK',
+            'Fuck retirement.',
+            '||',
+            'STEEL',
+            'Fuck retirement!',
+        ]))
+        self.assertEquals([DualDialog], [type(p) for p in paras])
+        dual = paras[0]
+        self.assertEquals('BRICK', dual.left.character)
+        self.assertEquals([(False, 'Fuck retirement.')], dual.left.blocks)
+        self.assertEquals('STEEL', dual.right.character)
+        self.assertEquals([(False, 'Fuck retirement!')], dual.right.blocks)
+
+    def test_standard_transition(self):
+        # Need clarification of the spec here, see
+        # http://prolost.com/blog/2011/8/9/screenplay-markdown.html?lastPage=true#comment14865294
+
+        paras = list(parse.parse([
+            'Jack begins to argue vociferously in Vietnamese (?)',
+            '',
+            'CUT TO:',
+            '',
+            "EXT. BRICK'S POOL - DAY",
+        ]))
+        self.assertEquals([Action, Transition, Slug], [type(p) for p in paras])
+
+if __name__ == '__main__':
+    unittest2.main()