~jaro/balkon

ref: 28d5a502818102ee72dc172d6e990f74532df2ef balkon/test/Data/Text/ParagraphLayout/Internal/TreeSpec.hs -rw-r--r-- 4.4 KiB
28d5a502 — Jaro Use ResolvedBox when flattening trees. 1 year, 10 days ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
module Data.Text.ParagraphLayout.Internal.TreeSpec (spec) where

import Test.Hspec
import Data.Text.ParagraphLayout.Internal.BoxOptions
import Data.Text.ParagraphLayout.Internal.ResolvedBox
import Data.Text.ParagraphLayout.Internal.TextOptions
import Data.Text.ParagraphLayout.Internal.Tree

complexTree :: RootNode String
complexTree = RootBox $ Box
    [ TextSequence "a" 1
    , InlineBox
        "box1"
        (Box
            [ TextSequence "b" 1
            , TextSequence "c" 1
            , InlineBox
                "box2"
                (Box
                    [ TextSequence "d" 1
                    , TextSequence "e" 1
                    ]
                    defaultTextOptions
                )
                defaultBoxOptions
            , TextSequence "f" 1
            , InlineBox
                "box3"
                (Box
                    [ TextSequence "g" 1
                    , InlineBox
                        "box4"
                        (Box
                            [ TextSequence "h" 1
                            ]
                            defaultTextOptions
                        )
                        defaultBoxOptions
                    , TextSequence "i" 1
                    ]
                    defaultTextOptions
                )
                defaultBoxOptions
            ]
            defaultTextOptions
        )
        defaultBoxOptions
    , InlineBox
        "box5"
        (Box
            [ InlineBox
                "box6"
                (Box
                    [ TextSequence "j" 1
                    , TextSequence "k" 1
                    ]
                    defaultTextOptions
                )
                defaultBoxOptions
            , InlineBox
                "box7"
                (Box
                    [ InlineBox
                        "box8"
                        (Box
                            [ TextSequence "l" 1
                            ]
                            defaultTextOptions
                        )
                        defaultBoxOptions
                    ]
                    defaultTextOptions
                )
                defaultBoxOptions
            , TextSequence "m" 1
            ]
            defaultTextOptions
        )
        defaultBoxOptions
    ]
    defaultTextOptions

leafData :: Leaf d -> d
leafData (TextLeaf d _ _ _) = d

leafPath :: Leaf d -> [ResolvedBox d]
leafPath (TextLeaf _ _ _ path) = path

leafDepth :: Leaf d -> Int
leafDepth = length . leafPath

leafPathData :: Leaf d -> [d]
leafPathData = map boxUserData . leafPath

leafPathIndexes :: Leaf d -> [Int]
leafPathIndexes = map boxIndex . leafPath

spec :: Spec
spec = do

    describe "flatten" $ do
        let leaves = flatten complexTree

        it "should have one leaf per text sequence" $
            length leaves `shouldBe` 13

        it "leaves should have expected data" $ do
            map leafData leaves `shouldBe`
                map (: []) ['a' .. 'm']

        it "leaves should have expected depths" $ do
            map leafDepth leaves `shouldBe`
                [0, 1, 1, 2, 2, 1, 2, 3, 2, 2, 2, 3, 1]

        it "leaves should have expected ancestor data" $ do
            map leafPathData leaves `shouldBe`
                [ []
                , ["box1"]
                , ["box1"]
                , ["box2", "box1"]
                , ["box2", "box1"]
                , ["box1"]
                , ["box3", "box1"]
                , ["box4", "box3", "box1"]
                , ["box3", "box1"]
                , ["box6", "box5"]
                , ["box6", "box5"]
                , ["box8", "box7", "box5"]
                , ["box5"]
                ]

        it "leaves should have expected ancestor indexes" $ do
            map leafPathIndexes leaves `shouldBe`
                [ []
                , [0]
                , [0]
                , [1, 0]
                , [1, 0]
                , [0]
                , [2, 0]
                , [3, 2, 0]
                , [2, 0]
                , [5, 4]
                , [5, 4]
                , [7, 6, 4]
                , [4]
                ]

        it "leaves 'c' and 'f' should have the same parent" $
            leafPath (leaves !! 2) !! 0 ==
            leafPath (leaves !! 5) !! 0 `shouldBe` True

        it "leaves 'e' and 'i' should have a different parent" $
            leafPath (leaves !! 4) !! 0 ==
            leafPath (leaves !! 8) !! 0 `shouldBe` False