Made RichString non-hierarchical (simpler).

Also: FDX output should have correct line breaks now.

3 files changed, 119 insertions, 83 deletions

diff --git a/tests/fdx_test.py b/tests/fdx_test.py
index 153a0cf..d97782f 100644
--- a/tests/fdx_test.py
+++ b/tests/fdx_test.py
@@ -2,8 +2,7 @@ import unittest2
 from StringIO import StringIO
 
 from screenplain.export.fdx import write_text
-
-from screenplain.richstring import RichString, Bold, Italic
+from screenplain.richstring import plain, bold, italic
 
 
 class OutputTests(unittest2.TestCase):
@@ -12,35 +11,45 @@ class OutputTests(unittest2.TestCase):
         self.out = StringIO()
 
     def test_plain_text_should_have_no_style(self):
-        write_text(self.out, RichString('hello'))
+        write_text(self.out, plain('hello'), False)
         self.assertEqual(
             self.out.getvalue(),
-            '<Text>hello</Text>'
+            '      <Text>hello</Text>\n'
         )
 
     def test_bold_text_should_have_bold_style(self):
-        write_text(self.out, Bold('hello'))
+        write_text(self.out, bold('hello'), False)
         self.assertEqual(
             self.out.getvalue(),
-            '<Text style="Bold">hello</Text>'
+            '      <Text style="Bold">hello</Text>\n'
         )
 
     def test_sequential_styles(self):
-        rich = RichString('plain', Bold('b'), Italic('i'))
-        write_text(self.out, rich)
+        rich = plain('plain') + bold('b') + italic('i')
+        write_text(self.out, rich, False)
+        self.assertEqual(
+            self.out.getvalue(),
+            '      <Text>plain</Text>\n'
+            '      <Text style="Bold">b</Text>\n'
+            '      <Text style="Italic">i</Text>\n'
+        )
+
+    def test_several_styles(self):
+        rich = bold('outer') +  (bold + italic)('inner') + bold('outer')
+        write_text(self.out, rich, False)
         self.assertEqual(
             self.out.getvalue(),
-            '<Text>plain</Text>'
-            '<Text style="Bold">b</Text>'
-            '<Text style="Italic">i</Text>'
+            '      <Text style="Bold">outer</Text>\n'
+            '      <Text style="Bold+Italic">inner</Text>\n'
+            '      <Text style="Bold">outer</Text>\n'
         )
 
-    def test_nested_styles(self):
-        rich = Bold('outer', Italic('inner'), 'outer')
-        write_text(self.out, rich)
+    def test_write_text_adds_line_break_if_requested(self):
+        rich = bold('outer') +  (bold + italic)('inner') + bold('outer')
+        write_text(self.out, rich, True)
         self.assertEqual(
             self.out.getvalue(),
-            '<Text style="Bold">outer</Text>'
-            '<Text style="Bold+Italic">inner</Text>'
-            '<Text style="Bold">outer</Text>'
+            '      <Text style="Bold">outer</Text>\n'
+            '      <Text style="Bold+Italic">inner</Text>\n'
+            '      <Text style="Bold">outer\n</Text>\n'  # note newline
         )
diff --git a/tests/richstring_test.py b/tests/richstring_test.py
index b442f90..c79981d 100644
--- a/tests/richstring_test.py
+++ b/tests/richstring_test.py
@@ -1,128 +1,154 @@
 import unittest2
-from screenplain.richstring import RichString, Bold, Italic, Underline
+from screenplain.richstring import (
+    RichString, Segment,
+    Bold, Italic,
+    plain, bold, italic, underline
+)
 from screenplain.richstring import parse_emphasis
 from screenplain.types import Slug, Action, Dialog, DualDialog, Transition
 
 
+class LowLevelRichStringTests(unittest2.TestCase):
+
+    def test_plain_string_has_one_single_segment(self):
+        s = RichString(plain('hello'))
+        self.assertEqual((plain('hello'),), s.segments)
+
+
 class RichStringOperatorTests(unittest2.TestCase):
 
     def test_repr(self):
-        s = RichString(Bold('Hello'), ' there ', Bold('folks'))
+        s = bold('Hello') + plain(' there ') + bold('folks')
         self.assertEquals(
-            "RichString(Bold('Hello'), ' there ', Bold('folks'))",
+            "(bold)('Hello') + (plain)(' there ') + (bold)('folks')",
             repr(s)
         )
 
     def test_eq(self):
-        self.assertEquals(Bold('Hello'), Bold('Hello'))
-        self.assertNotEquals(Bold('Hello'), Bold('Foo'))
-        self.assertNotEquals('Hello', Bold('Hello'))
+        self.assertEquals(bold('Hello'), bold('Hello'))
+        self.assertNotEquals(bold('Hello'), bold('Foo'))
+        self.assertNotEquals(plain('Hello'), bold('Hello'))
+
+    def test_ne(self):
+        self.assertFalse(bold('Hello') != bold('Hello'))
+
+    def test_concatenating_two_richstrings(self):
+        expected = RichString(Segment('hello', ()), Segment(' there', (Bold,)))
+        s1 = plain('hello')
+        s2 = bold(' there')
+        result = s1 + s2
+        self.assertEquals(expected, result)
+
+
+class StyleGeneratorTests(unittest2.TestCase):
+
+    def test_bold_function_creates_bold_richstring(self):
         self.assertEquals(
-            Bold('a', Italic('b'), 'c'),
-            Bold('a', Italic('b'), 'c')
-        )
-        self.assertNotEquals(
-            Bold('a', Italic('b'), 'c'),
-            Bold('a', Italic('b'), 'd')
+            RichString(Segment('a', (Bold,))),
+            bold('a')
         )
 
-    def test_ne(self):
-        self.assertFalse(Bold('Hello') != Bold('Hello'))
+    def test_adding_functions(self):
+        self.assertEquals(
+            RichString(Segment('a', (Bold, Italic))),
+            (bold + italic)('a')
+        )
 
 
 class RichStringTests(unittest2.TestCase):
 
     def test_plain_to_html(self):
-        self.assertEquals('hello', RichString('hello').to_html())
+        self.assertEquals('hello', RichString(plain('hello')).to_html())
 
     def test_to_html(self):
         s = RichString(
-            Bold('bold'),
-            ' normal ',
-            Italic('italic'),
-            Underline('wonderline')
+            bold('bold'),
+            plain(' normal '),
+            italic('italic'),
+            underline('wonderline')
         )
         self.assertEquals(
             '<strong>bold</strong> normal <em>italic</em><u>wonderline</u>',
             s.to_html()
         )
 
-
 class ParseEmphasisTests(unittest2.TestCase):
 
     def test_parse_without_emphasis(self):
-        self.assertEquals(RichString('Hello'), parse_emphasis('Hello'),
-            'Expected parse_emphasis to return a string')
+        self.assertEquals(plain('Hello'), parse_emphasis('Hello'),
+            'Expected parse_emphasis to return a plain string')
 
     def test_parse_bold(self):
         self.assertEquals(
             parse_emphasis('**Hello**'),
-            Bold('Hello')
+            bold('Hello')
         )
 
     def test_parse_pre_and_postfix_and_bold(self):
         self.assertEquals(
             parse_emphasis('pre**Hello**post'),
-            RichString('pre', Bold('Hello'), 'post'),
+            plain('pre') +  bold('Hello') + plain('post')
         )
 
     def test_parse_multiple_bold(self):
         self.assertEquals(
             parse_emphasis('x**Hello** **there**'),
-            RichString('x', Bold('Hello'), ' ', Bold('there'))
+            plain('x') + bold('Hello') + plain(' ') + bold('there')
         )
 
     def test_parse_adjacent_bold(self):
         self.assertEquals(
-            parse_emphasis('**123****456**'),
-            RichString(Bold('123**'), '456**')
+            parse_emphasis('**123**456**'),
+            bold('123') + plain('456**')
         )
 
     def test_italic(self):
         self.assertEquals(
             parse_emphasis('*Italian style*'),
-            Italic('Italian style')
+            italic('Italian style')
         )
 
     def test_bold_inside_italic(self):
         self.assertEquals(
             parse_emphasis('*Swedish **style** rules*'),
-            Italic('Swedish ', Bold('style'), ' rules')
+            italic('Swedish ') + (bold + italic)('style') + italic(' rules')
         )
 
     def test_italic_inside_bold(self):
         self.assertEquals(
             parse_emphasis('**Swedish *style* rules**'),
-            Bold('Swedish ', Italic('style'), ' rules')
+            bold('Swedish ') + (bold + italic)('style') + bold(' rules')
         )
 
     def test_italic_and_bold(self):
         self.assertEquals(
             parse_emphasis('***really strong***'),
-            Bold(Italic('really strong'))
+            (bold + italic)('really strong')
         )
 
     @unittest2.expectedFailure
     def test_additional_star(self):
         self.assertEquals(
             parse_emphasis('*foo* bar* baz'),
-            RichString(Italic('foo'), ' bar* baz')
+            italic('foo') + plain(' bar* baz')
         )
 
     def test_underline(self):
         self.assertEquals(
             parse_emphasis('_hello_'),
-            Underline('hello')
+            underline('hello')
         )
 
     def test_bold_inside_underline(self):
         self.assertEquals(
             parse_emphasis('_**hello**_'),
-            Underline(Bold('hello'))
+            (bold + underline)('hello')
         )
 
     def test_overlapping_underscore_and_italic(self):
+        # It's unclear what result to expect in this case.
+        # This is one way of interpreting it
         self.assertEquals(
             parse_emphasis('_*he_llo*'),
-            RichString(Underline('*he'), 'llo*')
+            (italic + underline)('he') + italic('llo')
         )
diff --git a/tests/spmd_test.py b/tests/spmd_test.py
index 1f5c0f5..fbc7867 100644
--- a/tests/spmd_test.py
+++ b/tests/spmd_test.py
@@ -1,7 +1,7 @@
 import unittest2
 from screenplain.parsers.spmd import parse
 from screenplain.types import Slug, Action, Dialog, DualDialog, Transition
-
+from screenplain.richstring import plain
 
 class ParseTests(unittest2.TestCase):
 
@@ -28,8 +28,8 @@ class ParseTests(unittest2.TestCase):
         self.assertEquals([Dialog, Action], [type(p) for p in paras])
         # What looks like a scene headingis parsed as a character name.
         # Unexpected perhaps, but that's how I interpreted the spec.
-        self.assertEquals('INT. SOMEWHERE - DAY', paras[0].character)
-        self.assertEquals(['Some action'], paras[1].lines)
+        self.assertEquals(plain('INT. SOMEWHERE - DAY'), paras[0].character)
+        self.assertEquals([plain('Some action')], paras[1].lines)
 
     def test_action_is_not_a_slug(self):
         paras = list(parse([
@@ -57,7 +57,7 @@ class ParseTests(unittest2.TestCase):
         self.assertEquals(1, len(paras))
         dialog = paras[0]
         self.assertEquals(Dialog, type(dialog))
-        self.assertEquals('SOME GUY', dialog.character)
+        self.assertEquals(plain('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.
@@ -86,8 +86,14 @@ class ParseTests(unittest2.TestCase):
         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])
+        self.assertEqual(
+            (True, plain('(starting the engine)')),
+            dialog.blocks[0]
+        )
+        self.assertEqual(
+            (False, plain('So much for retirement!')),
+            dialog.blocks[1]
+        )
 
     def test_dual_dialog(self):
         paras = list(parse([
@@ -99,10 +105,16 @@ class ParseTests(unittest2.TestCase):
         ]))
         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)
+        self.assertEquals(plain('BRICK'), dual.left.character)
+        self.assertEquals(
+            [(False, plain('Fuck retirement.'))],
+            dual.left.blocks
+        )
+        self.assertEquals(plain('STEEL'), dual.right.character)
+        self.assertEquals(
+            [(False, plain('Fuck retirement!'))],
+            dual.right.blocks
+        )
 
     def test_dual_dialog_with_empty_right_dialog_is_ordinary_dialog(self):
         paras = list(parse([
@@ -112,10 +124,10 @@ class ParseTests(unittest2.TestCase):
         ]))
         self.assertEquals([Dialog], [type(p) for p in paras])
         dialog = paras[0]
-        self.assertEqual('BRICK', dialog.character)
+        self.assertEqual(plain('BRICK'), dialog.character)
         self.assertEqual([
-            (False, 'Nice retirement.'),
-            (False, '||')
+            (False, plain('Nice retirement.')),
+            (False, plain('||'))
         ], dialog.blocks)
 
     def test_standard_transition(self):
@@ -129,17 +141,6 @@ class ParseTests(unittest2.TestCase):
         ]))
         self.assertEquals([Action, Transition, Slug], [type(p) for p in paras])
 
-    def test_standard_transition(self):
-
-        paras = list(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])
-
     def test_transition_needs_to_be_upper_case(self):
         paras = list(parse([
             'Jack begins to argue vociferously in Vietnamese (?)',
@@ -185,9 +186,9 @@ class ParseTests(unittest2.TestCase):
         self.assertEquals([Action, Action, Action], [type(p) for p in paras])
         self.assertEquals(
             [
-                "And then there's a long beat.",
-                "Longer than is funny.",
-                "Long enough to be depressing.",
+                plain("And then there's a long beat."),
+                plain("Longer than is funny."),
+                plain("Long enough to be depressing."),
             ], paras[1].lines
         )
 
@@ -201,10 +202,10 @@ class ParseTests(unittest2.TestCase):
         ]))
         self.assertEquals([Dialog], [type(p) for p in paras])
         self.assertEquals([
-            (False, 'O Romeo, Romeo! wherefore art thou Romeo?'),
-            (False, 'Deny thy father and refuse thy name;'),
-            (False, 'Or, if thou wilt not, be but sworn my love,'),
-            (False, "And I'll no longer be a Capulet."),
+            (False, plain('O Romeo, Romeo! wherefore art thou Romeo?')),
+            (False, plain('Deny thy father and refuse thy name;')),
+            (False, plain('Or, if thou wilt not, be but sworn my love,')),
+            (False, plain("And I'll no longer be a Capulet.")),
         ], paras[0].blocks)
 
 if __name__ == '__main__':