sile 0.14.8

Simon’s Improved Layout Engine
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

SILE = require("core.sile")

describe("SILE.utilities", function()
  it("should exist", function()
    assert.is.truthy(SU)
  end)

  describe("utf8_to_utf16be_hexencoded ", function()
    it("should hex encode input", function()
      local str = "foo"
      local out = "feff0066006f006f"
      assert.is.equal(out, SU.utf8_to_utf16be_hexencoded(str))
    end)
  end)

  describe("formatNumber", function ()

    SILE.documentState = { documentClass = { state = { } } }
    SILE.typesetter = SILE.typesetters.base(SILE.newFrame({ id = "dummy" }))

    describe ("Esperanto", function ()
      SILE.call("language", { main = "eo" }) -- Really load AND activate the language
      -- The test assumes Espeeranto has its own language-specific hooks, bypassing ICU.

      it("should format strings", function ()
        -- Directly checking the language-specific hooks
        assert.is.equal("miliono", SU.formatNumber.eo.string(1000000))
        assert.is.equal("miliono kaj unu", SU.formatNumber.eo.string(1000001))
        assert.is.equal("tri milionoj kaj tri", SU.formatNumber.eo.string(3000003))
        assert.is.equal("tri miliardoj kaj tri cent tri dek tri milionoj kaj tri cent mil tri dek", SU.formatNumber.eo.string(3333300030))
        -- Called via basic SILE.formatNumber() when the language is set.
        assert.is.equal("miliono kaj unu", SU.formatNumber(1000001, { style = "string" }))
      end)

      it("should format ordinal numbers", function ()
        -- Directly checking the language-specific hooks
        assert.is.equal("1a", SU.formatNumber.eo.ordinal(1))
        assert.is.equal("99a", SU.formatNumber.eo.ordinal(99))
        -- Called via basic SILE.formatNumber() when the language is set.
        assert.is.equal("1a", SU.formatNumber(1, { style = "ordinal" }))
        assert.is.equal("99a", SU.formatNumber(99, { style = "ordinal" }))
      end)
    end)

    describe ("French", function ()
      SILE.call("language", { main = "fr" }) -- Really load AND activate the language
      -- The test assumes French is relying on ICU.

      it("should format strings", function ()
        assert.is.equal("mille neuf cent quatre-vingt-quatre", SU.formatNumber(1984, { style = "string" }))
      end)

      it("should format default numbers", function ()
        assert.is.equal("1984", SU.formatNumber(1984, { style = "default" }))
      end)

      it("should format decimal numbers", function ()
        assert.is.equal("1 984", -- N.B. Contains a non-breaking space
                        SU.formatNumber(1984, { style = "decimal" }))
      end)

      it("should format ordinal numbers", function ()
        assert.is.equal("1 984e", -- N.B. Contains a non-breaking space
                        SU.formatNumber(1984, { style = "ordinal" }))
      end)
    end)

    describe ("English", function ()
      SILE.call("language", { main = "en" }) -- Really load AND activate the language
      -- The test assumes English is relying both on ICU and language-specific hooks

      it("should format strings", function ()
        assert.is.equal("one thousand nine hundred eighty-four", SU.formatNumber(1984, { style = "string" }))
      end)

      it("should format default numbers", function ()
        assert.is.equal("1984", SU.formatNumber(1984, { style = "default" }))
      end)

      it("should format decimal numbers", function ()
        assert.is.equal("1,984", SU.formatNumber(1984, { style = "decimal" }))
      end)

      it("should format ordinal numbers", function ()
        assert.is.equal("1,984th", SU.formatNumber(1984, { style = "ordinal" }))
      end)
    end)

    describe ("Russian", function ()
      SILE.call("language", { main = "ru" }) -- Really load AND activate the language
      -- The test assumes Arabic language is relying on ICU

      it("should format strings", function ()
        assert.is.equal("одна тысяча девятьсот восемьдесят четыре", SU.formatNumber(1984, { style = "string" }))
      end)

      it("should format default numbers", function ()
        assert.is.equal("1984", SU.formatNumber(1984, { style = "default" }))
      end)

      it("should format decimal numbers", function ()
        assert.is.equal("1 984", -- N.B. Contains a non-breaking space
                        SU.formatNumber(1984, { style = "decimal" }))
      end)

      it("should format ordinal numbers", function ()
        assert.is.equal("1 984.", -- N.B. Contains a non-breaking space
                        SU.formatNumber(1984, { style = "ordinal" }))
      end)
    end)

    describe ("Arabic", function ()
      SILE.call("language", { main = "ar" }) -- Really load AND activate the language
      -- The test assumes Arabic language is relying on ICU

      it("should format default numbers", function ()
        assert.is.equal("١٩٨٤", SU.formatNumber(1984, { style = "default" }))
      end)

      it("should format decimal numbers", function ()
        assert.is.equal("١٬٩٨٤", SU.formatNumber(1984, { style = "decimal" }))
      end)

      it("should format ordinal numbers", function ()
        assert.is.equal("١٬٩٨٤.", SU.formatNumber(1984, { style = "ordinal" }))
      end)
    end)

    describe ("Numbering systems", function ()
      SILE.call("language", { main = "en" }) -- Really load AND activate the language
      -- Just to have a language

      it("should format 'latin' numbers", function ()
        assert.is.equal("2", SU.formatNumber(2, { system = "latn" }))
        assert.is.equal("2", SU.formatNumber(2, { system = "arabic" }))
      end)

      it("should format roman number", function ()
        assert.is.equal("mcmlxxxiv", SU.formatNumber(1984, { system = "roman" }))
      end)

      it("should format ROMAN number", function ()
        assert.is.equal("MCMLXXXIV", SU.formatNumber(1984, { system = "ROMAN" }))
      end)

      it("should format alpha number", function ()
        assert.is.equal("b", SU.formatNumber(2, { system = "alpha" }))
      end)

      it("should format ALPHA number", function ()
        assert.is.equal("B", SU.formatNumber(2, { system = "Alpha" }))
      end)

      it("should format 'arab' numbers", function ()
        assert.is.equal("٢", SU.formatNumber(2, { system = "arab" }))
      end)
    end)
  end)

  describe("collatedSort", function ()

    SILE.documentState = { documentClass = { state = { } } }
    SILE.typesetter = SILE.typesetters.base(SILE.newFrame({ id = "dummy" }))

    describe ("French", function ()
      SILE.call("language", { main = "fr" }) -- Really load AND activate the language

      -- Our reference 'unsorted' table.
      -- Just as table.sort(t), SU.collatedSort(t) has a side-effect on the table, we'll need
      -- to shallow copy it, for each test to be independent from the others.
      local original = {
        "Albert", "Jean2", "Alain", "Jean100", "alain", "alinoé", "Jean-Paul", "Alinéa", "Jean2", "jeanne" }

      it("should have expected default sorting", function ()
        local sortme = pl.tablex.copy(original)
        SU.collatedSort(sortme) -- with default options
        assert.is.same({
          "alain", "Alain", "Albert","Alinéa", "alinoé", "Jean2", "Jean2", "Jean100", "jeanne", "Jean-Paul" }, sortme)
      end)
      it("should have expected sorting when ignorePunctuation is disabled", function ()
        local sortme = pl.tablex.copy(original)
        SU.collatedSort(sortme, { ignorePunctuation = false })
        assert.is.same({
          -- Jean-Paul is the guinea pig!
          "alain", "Alain", "Albert", "Alinéa", "alinoé", "Jean-Paul", "Jean2", "Jean2", "Jean100", "jeanne" }, sortme)
      end)
      it("should have expected sorting when numericOrdering is disabled", function ()
        local sortme = pl.tablex.copy(original)
        SU.collatedSort(sortme, { numericOrdering = false })
        assert.is.same({
          -- Jean100 and the Jean2 are the guinea pigs!
          "alain", "Alain", "Albert", "Alinéa", "alinoé", "Jean100", "Jean2", "Jean2", "jeanne", "Jean-Paul" }, sortme)
      end)
      it("should have expected sorting when caseFirst is 'upper'", function ()
        local sortme = pl.tablex.copy(original)
        SU.collatedSort(sortme, { caseFirst = "upper" })
        assert.is.same({
          -- Alain is the guinea pig!
          "Alain", "alain", "Albert", "Alinéa", "alinoé", "Jean2", "Jean2", "Jean100", "jeanne", "Jean-Paul" }, sortme)
      end)
      it("should have expected sorting when language-specific options are configured", function ()
        -- WARNING: This is expected to be used for languages where the default options
        -- are not appropriate. I'm told for example that Japanese may need strength=4.
        -- I've not idea however, so let's BREAK the default French rules for testing!
        SU.collatedSort.fr = { caseFirst = "upper", numericOrdering = false }
        local sortme = pl.tablex.copy(original)
        SU.collatedSort(sortme) -- with default options as overriden.
        assert.is.same({
          -- Alain and the Jean guys are the guinea pigs!
          "Alain", "alain", "Albert", "Alinéa", "alinoé", "Jean100", "Jean2", "Jean2", "jeanne", "Jean-Paul" }, sortme)
      end)
    end)
  end)

end)