PageRenderTime 64ms CodeModel.GetById 31ms RepoModel.GetById 0ms app.codeStats 0ms

/test/camelot/test/fo.clj

https://github.com/democracyworks/camelot
Clojure | 576 lines | 560 code | 16 blank | 0 comment | 25 complexity | 434e441598a807455ad3d7c004a3350b MD5 | raw file
    

  1. (ns camelot.test.fo
    2. 

  2.   (:use [clojure.test]
    3. 

  3.         [camelot.test.helpers]
    4. 

  4.         [camelot.fo] :reload)
    5. 

  5.   (:require [clojure.data.xml :as xml])
    6. 

  6.   (:import [java.io File]
    7. 

  7.            [org.apache.pdfbox.util PDFTextStripper]
    8. 

  8.            [org.apache.pdfbox.pdmodel PDDocument]))
    9. 

  9. 

  10. (deftest test-layout
    11. 

  11.   (is (= (layout {})
    12. 

  12.          #clojure.data.xml.Element{
    13. 

  13.            :tag :fo:layout-master-set
    14. 

  14.            :attrs {}
    15. 

  15.            :content
    16. 

  16.              (#clojure.data.xml.Element{
    17. 

  17.                :tag :fo:simple-page-master
    18. 

  18.                :attrs {:master-name "first"
    19. 

  19.                        :margin-right "1.5cm"
    20. 

  20.                        :margin-left "1.5cm"
    21. 

  21.                        :margin-bottom "2cm"
    22. 

  22.                        :margin-top "1cm"
    23. 

  23.                        :page-width "211mm"
    24. 

  24.                        :page-height "297mm"}
    25. 

  25.                :content
    26. 

  26.                  (#clojure.data.xml.Element{
    27. 

  27.                    :tag :fo:region-body
    28. 

  28.                    :attrs {:margin-top "0cm"}
    29. 

  29.                    :content ()}
    30. 

  30.                  #clojure.data.xml.Element{
    31. 

  31.                    :tag :fo:region-before
    32. 

  32.                    :attrs {:extent "1cm"}
    33. 

  33.                    :content ()}
    34. 

  34.                  #clojure.data.xml.Element{
    35. 

  35.                    :tag :fo:region-after
    36. 

  36.                    :attrs {:extent "1.5cm"}
    37. 

  37.                    :content ()})})}))
    38. 

  38.   
    39. 

  39.   (is (= (layout {:margin-right "1:42cm"
    40. 

  40.                   :margin-left "2:42cm"
    41. 

  41.                   :margin-bottom "3:42cm"
    42. 

  42.                   :margin-top "4:42cm"
    43. 

  43.                   :page-width "5:42mm"
    44. 

  44.                   :page-height "6:42mm"
    45. 

  45.                   :region-body {:margin-top "3cm"}
    46. 

  46.                   :region-before {:extent "2cm"}
    47. 

  47.                   :region-after {:extent "1cm"}})
    48. 

  48.          #clojure.data.xml.Element{
    49. 

  49.            :tag :fo:layout-master-set
    50. 

  50.            :attrs {}
    51. 

  51.            :content
    52. 

  52.              (#clojure.data.xml.Element{
    53. 

  53.                :tag :fo:simple-page-master
    54. 

  54.                :attrs {:master-name "first"
    55. 

  55.                        :margin-right "1:42cm"
    56. 

  56.                        :margin-left "2:42cm"
    57. 

  57.                        :margin-bottom "3:42cm"
    58. 

  58.                        :margin-top "4:42cm"
    59. 

  59.                        :page-width "5:42mm"
    60. 

  60.                        :page-height "6:42mm"}
    61. 

  61.                :content
    62. 

  62.                  (#clojure.data.xml.Element{
    63. 

  63.                    :tag :fo:region-body
    64. 

  64.                    :attrs {:margin-top "3cm"}
    65. 

  65.                    :content ()}
    66. 

  66.                  #clojure.data.xml.Element{
    67. 

  67.                    :tag :fo:region-before
    68. 

  68.                    :attrs {:extent "2cm"}
    69. 

  69.                    :content ()}
    70. 

  70.                  #clojure.data.xml.Element{
    71. 

  71.                    :tag :fo:region-after
    72. 

  72.                    :attrs {:extent "1cm"}
    73. 

  73.                    :content ()})})})))
    74. 

  74. 

  75. (deftest test-block?
    76. 

  76.   (are [v] (not (block? v))
    77. 

  77.        nil
    78. 

  78.        {:tag :fo:block}
    79. 

  79.        (xml/element :fo:not-block {} "hey"))
    80. 

  80. 

  81.   (are [v] (block? v)
    82. 

  82.        (xml/element :fo:block {} "hey")
    83. 

  83.        (block "hey")))
    84. 

  84. 

  85. (deftest test-block
    86. 

  86.   (is (= (block "Hic sunt dracones.")
    87. 

  87.          #clojure.data.xml.Element{
    88. 

  88.            :tag :fo:block
    89. 

  89.            :attrs {:text-align "left"
    90. 

  90.                    :font-size "10pt"
    91. 

  91.                    :line-height "14pt"}
    92. 

  92.            :content ("Hic sunt dracones.")}))
    93. 

  93. 

  94.   (is (= (block {:space-before.optimum "10pt"
    95. 

  95.                  :space-after.optimum "20pt"
    96. 

  96.                  :text-align "end"}
    97. 

  97.                 "Hic sunt dracones.")
    98. 

  98.          #clojure.data.xml.Element{
    99. 

  99.            :tag :fo:block
    100. 

  100.            :attrs {:text-align "end"
    101. 

  101.                    :font-size "10pt"
    102. 

  102.                    :line-height "14pt"
    103. 

  103.                    :space-before.optimum "10pt"
    104. 

  104.                    :space-after.optimum "20pt"}
    105. 

  105.            :content ("Hic sunt dracones.")}))
    106. 

  106. 

  107.   (is (= (block [(block "A") (block "B")])
    108. 

  108.          #clojure.data.xml.Element{
    109. 

  109.            :tag :fo:block
    110. 

  110.            :attrs {:text-align "left"
    111. 

  111.                    :font-size "10pt"
    112. 

  112.                    :line-height "14pt"}
    113. 

  113.            :content (#clojure.data.xml.Element{
    114. 

  114.                        :tag :fo:block
    115. 

  115.                        :attrs {:text-align "left"
    116. 

  116.                                :font-size "10pt"
    117. 

  117.                                :line-height "14pt"}
    118. 

  118.                        :content ("A")}
    119. 

  119.                      #clojure.data.xml.Element{
    120. 

  120.                        :tag :fo:block
    121. 

  121.                        :attrs {:text-align "left"
    122. 

  122.                                :font-size "10pt"
    123. 

  123.                                :line-height "14pt"}
    124. 

  124.                        :content ("B")})})))
    125. 

  125. 

  126. (deftest test-table-cell
    127. 

  127.   (is (= (table-cell "Foo")
    128. 

  128.          #clojure.data.xml.Element{
    129. 

  129.            :tag :fo:table-cell
    130. 

  130.            :attrs {}
    131. 

  131.            :content (#clojure.data.xml.Element{
    132. 

  132.                        :tag :fo:block
    133. 

  133.                        :attrs {:text-align "left"
    134. 

  134.                                :font-size "10pt"
    135. 

  135.                                :line-height "14pt"}
    136. 

  136.                        :content ("Foo")})}))
    137. 

  137.   (is (= (table-cell (block {:text-align "right"} "Foo"))
    138. 

  138.          #clojure.data.xml.Element{
    139. 

  139.            :tag :fo:table-cell
    140. 

  140.            :attrs {}
    141. 

  141.            :content (#clojure.data.xml.Element{
    142. 

  142.                        :tag :fo:block
    143. 

  143.                        :attrs {:text-align "right"
    144. 

  144.                                :font-size "10pt"
    145. 

  145.                                :line-height "14pt"}
    146. 

  146.                        :content ("Foo")})})))
    147. 

  147. 

  148. (deftest test-table-row-has-attributes?
    149. 

  149.   (is (table-row-has-attributes? [{:foo "bar"} "A" "B" "C"]))
    150. 

  150.   (are [v] (not (table-row-has-attributes? v))
    151. 

  151.        [(block "A") "B" "C"]
    152. 

  152.        ["A" "B" "C"]))
    153. 

  153. 

  154. (deftest test-table-row
    155. 

  155.   (is (= (table-row "A" "B" "C")
    156. 

  156.          #clojure.data.xml.Element{
    157. 

  157.            :tag :fo:table-row
    158. 

  158.            :attrs {}
    159. 

  159.            :content (#clojure.data.xml.Element{
    160. 

  160.                        :tag :fo:table-cell
    161. 

  161.                        :attrs {}
    162. 

  162.                        :content (#clojure.data.xml.Element{
    163. 

  163.                                    :tag :fo:block
    164. 

  164.                                    :attrs {:text-align "left"
    165. 

  165.                                            :font-size "10pt"
    166. 

  166.                                            :line-height "14pt"}
    167. 

  167.                                    :content ("A")})}
    168. 

  168.                      #clojure.data.xml.Element{
    169. 

  169.                        :tag :fo:table-cell
    170. 

  170.                        :attrs {}
    171. 

  171.                        :content (#clojure.data.xml.Element{
    172. 

  172.                                    :tag :fo:block
    173. 

  173.                                    :attrs {:text-align "left"
    174. 

  174.                                            :font-size "10pt"
    175. 

  175.                                            :line-height "14pt"}
    176. 

  176.                                    :content ("B")})}
    177. 

  177.                      #clojure.data.xml.Element{
    178. 

  178.                        :tag :fo:table-cell
    179. 

  179.                        :attrs {}
    180. 

  180.                        :content (#clojure.data.xml.Element{
    181. 

  181.                                    :tag :fo:block
    182. 

  182.                                    :attrs {:text-align "left"
    183. 

  183.                                            :font-size "10pt"
    184. 

  184.                                            :line-height "14pt"}
    185. 

  185.                                    :content ("C")})})}))
    186. 

  186.   (is (= (table-row (block {:font-weight "bold"} "A") "B" "C")
    187. 

  187.          #clojure.data.xml.Element{
    188. 

  188.            :tag :fo:table-row
    189. 

  189.            :attrs {}
    190. 

  190.            :content (#clojure.data.xml.Element{
    191. 

  191.                        :tag :fo:table-cell
    192. 

  192.                        :attrs {}
    193. 

  193.                        :content (#clojure.data.xml.Element{
    194. 

  194.                                    :tag :fo:block
    195. 

  195.                                    :attrs {:text-align "left"
    196. 

  196.                                            :font-size "10pt"
    197. 

  197.                                            :line-height "14pt"
    198. 

  198.                                            :font-weight "bold"}
    199. 

  199.                                    :content ("A")})}
    200. 

  200.                      #clojure.data.xml.Element{
    201. 

  201.                        :tag :fo:table-cell
    202. 

  202.                        :attrs {}
    203. 

  203.                        :content (#clojure.data.xml.Element{
    204. 

  204.                                    :tag :fo:block
    205. 

  205.                                    :attrs {:text-align "left"
    206. 

  206.                                            :font-size "10pt"
    207. 

  207.                                            :line-height "14pt"}
    208. 

  208.                                    :content ("B")})}
    209. 

  209.                      #clojure.data.xml.Element{
    210. 

  210.                        :tag :fo:table-cell
    211. 

  211.                        :attrs {}
    212. 

  212.                        :content (#clojure.data.xml.Element{
    213. 

  213.                                    :tag :fo:block
    214. 

  214.                                    :attrs {:text-align "left"
    215. 

  215.                                            :font-size "10pt"
    216. 

  216.                                            :line-height "14pt"}
    217. 

  217.                                    :content ("C")})})}))
    218. 

  218.   (is (= (table-row {:border-width "0.5pt" :keep-with-next "always"}
    219. 

  219.                     (block {:font-weight "bold"} "A"))
    220. 

  220.          #clojure.data.xml.Element{
    221. 

  221.            :tag :fo:table-row
    222. 

  222.            :attrs {:border-width "0.5pt"
    223. 

  223.                    :keep-with-next "always"}
    224. 

  224.            :content (#clojure.data.xml.Element{
    225. 

  225.                        :tag :fo:table-cell
    226. 

  226.                        :attrs {}
    227. 

  227.         :content (#clojure.data.xml.Element{
    228. 

  228.                     :tag :fo:block
    229. 

  229.                     :attrs {:text-align "left"
    230. 

  230.                             :font-size "10pt"
    231. 

  231.                             :line-height "14pt"
    232. 

  232.                             :font-weight "bold"}
    233. 

  233.                     :content ("A")})})})))
    234. 

  234. 

  235. (deftest test-table-column
    236. 

  236.   (is (= (table-column "10cm")
    237. 

  237.          #clojure.data.xml.Element{:tag :fo:table-column
    238. 

  238.                                    :attrs {:column-width "10cm"}
    239. 

  239.                                    :content ()}))
    240. 

  240.   
    241. 

  241.     (is (= (table-column {:column-height "3cm"} "10cm")
    242. 

  242.          #clojure.data.xml.Element{:tag :fo:table-column
    243. 

  243.                                    :attrs {:column-width "10cm"
    244. 

  244.                                            :column-height "3cm"}
    245. 

  245.                                    :content ()})))
    246. 

  246. 

  247. (deftest test-table
    248. 

  248.   (is (= (table ["5cm" "5cm"] [["a" "b"] ["c" "d"]])
    249. 

  249.          #clojure.data.xml.Element{
    250. 

  250.            :tag :fo:table
    251. 

  251.            :attrs {:border-width "0.5pt"}
    252. 

  252.            :content
    253. 

  253.              (#clojure.data.xml.Element{
    254. 

  254.                :tag :fo:table-column
    255. 

  255.                :attrs {:column-width "5cm"}
    256. 

  256.                :content ()}
    257. 

  257.               #clojure.data.xml.Element{
    258. 

  258.                :tag :fo:table-column
    259. 

  259.                :attrs {:column-width "5cm"}
    260. 

  260.                :content ()}
    261. 

  261.               #clojure.data.xml.Element{
    262. 

  262.                 :tag :fo:table-body
    263. 

  263.                 :attrs {}
    264. 

  264.                 :content
    265. 

  265.                   (#clojure.data.xml.Element{
    266. 

  266.                     :tag :fo:table-row
    267. 

  267.                     :attrs {:border-width "0.5pt"
    268. 

  268.                     :keep-with-next "always"}
    269. 

  269.                     :content
    270. 

  270.                       (#clojure.data.xml.Element{
    271. 

  271.                         :tag :fo:table-cell
    272. 

  272.                         :attrs {}
    273. 

  273.                         :content
    274. 

  274.                           (#clojure.data.xml.Element{
    275. 

  275.                             :tag :fo:block
    276. 

  276.                             :attrs {:text-align "left"
    277. 

  277.                                     :font-size "10pt"
    278. 

  278.                                     :line-height "14pt"}
    279. 

  279.                                     :content ("a")})}
    280. 

  280.                        #clojure.data.xml.Element{
    281. 

  281.                         :tag :fo:table-cell
    282. 

  282.                         :attrs {}
    283. 

  283.                         :content
    284. 

  284.                           (#clojure.data.xml.Element{
    285. 

  285.                             :tag :fo:block
    286. 

  286.                             :attrs {:text-align "left"
    287. 

  287.                                     :font-size "10pt"
    288. 

  288.                                     :line-height "14pt"}
    289. 

  289.                                     :content ("b")})})}
    290. 

  290.                    #clojure.data.xml.Element{
    291. 

  291.                     :tag :fo:table-row
    292. 

  292.                     :attrs {}
    293. 

  293.                     :content
    294. 

  294.                       (#clojure.data.xml.Element{
    295. 

  295.                         :tag :fo:table-cell
    296. 

  296.                         :attrs {}
    297. 

  297.                         :content
    298. 

  298.                           (#clojure.data.xml.Element{
    299. 

  299.                             :tag :fo:block
    300. 

  300.                             :attrs {:text-align "left"
    301. 

  301.                                     :font-size "10pt"
    302. 

  302.                                     :line-height "14pt"}
    303. 

  303.                                     :content ("c")})}
    304. 

  304.                        #clojure.data.xml.Element{
    305. 

  305.                         :tag :fo:table-cell
    306. 

  306.                         :attrs {}
    307. 

  307.                         :content
    308. 

  308.                           (#clojure.data.xml.Element{
    309. 

  309.                             :tag :fo:block
    310. 

  310.                             :attrs {:text-align "left"
    311. 

  311.                                     :font-size "10pt"
    312. 

  312.                                     :line-height "14pt"}
    313. 

  313.                                     :content ("d")})})})})}))
    314. 

  314.     (is (= (table {:foo "bar"} ["5cm" "5cm"] [["a" "b"] ["c" "d"]])
    315. 

  315.          #clojure.data.xml.Element{
    316. 

  316.            :tag :fo:table
    317. 

  317.            :attrs {:foo "bar"}
    318. 

  318.            :content
    319. 

  319.              (#clojure.data.xml.Element{
    320. 

  320.                :tag :fo:table-column
    321. 

  321.                :attrs {:column-width "5cm"}
    322. 

  322.                :content ()}
    323. 

  323.               #clojure.data.xml.Element{
    324. 

  324.                :tag :fo:table-column
    325. 

  325.                :attrs {:column-width "5cm"}
    326. 

  326.                :content ()}
    327. 

  327.               #clojure.data.xml.Element{
    328. 

  328.                 :tag :fo:table-body
    329. 

  329.                 :attrs {}
    330. 

  330.                 :content
    331. 

  331.                   (#clojure.data.xml.Element{
    332. 

  332.                     :tag :fo:table-row
    333. 

  333.                     :attrs {:border-width "0.5pt"
    334. 

  334.                     :keep-with-next "always"}
    335. 

  335.                     :content
    336. 

  336.                       (#clojure.data.xml.Element{
    337. 

  337.                         :tag :fo:table-cell
    338. 

  338.                         :attrs {}
    339. 

  339.                         :content
    340. 

  340.                           (#clojure.data.xml.Element{
    341. 

  341.                             :tag :fo:block
    342. 

  342.                             :attrs {:text-align "left"
    343. 

  343.                                     :font-size "10pt"
    344. 

  344.                                     :line-height "14pt"}
    345. 

  345.                                     :content ("a")})}
    346. 

  346.                        #clojure.data.xml.Element{
    347. 

  347.                         :tag :fo:table-cell
    348. 

  348.                         :attrs {}
    349. 

  349.                         :content
    350. 

  350.                           (#clojure.data.xml.Element{
    351. 

  351.                             :tag :fo:block
    352. 

  352.                             :attrs {:text-align "left"
    353. 

  353.                                     :font-size "10pt"
    354. 

  354.                                     :line-height "14pt"}
    355. 

  355.                                     :content ("b")})})}
    356. 

  356.                    #clojure.data.xml.Element{
    357. 

  357.                     :tag :fo:table-row
    358. 

  358.                     :attrs {}
    359. 

  359.                     :content
    360. 

  360.                       (#clojure.data.xml.Element{
    361. 

  361.                         :tag :fo:table-cell
    362. 

  362.                         :attrs {}
    363. 

  363.                         :content
    364. 

  364.                           (#clojure.data.xml.Element{
    365. 

  365.                             :tag :fo:block
    366. 

  366.                             :attrs {:text-align "left"
    367. 

  367.                                     :font-size "10pt"
    368. 

  368.                                     :line-height "14pt"}
    369. 

  369.                                     :content ("c")})}
    370. 

  370.                        #clojure.data.xml.Element{
    371. 

  371.                         :tag :fo:table-cell
    372. 

  372.                         :attrs {}
    373. 

  373.                         :content
    374. 

  374.                           (#clojure.data.xml.Element{
    375. 

  375.                             :tag :fo:block
    376. 

  376.                             :attrs {:text-align "left"
    377. 

  377.                                     :font-size "10pt"
    378. 

  378.                                     :line-height "14pt"}
    379. 

  379.                                     :content ("d")})})})})}))
    380. 

  380.   (is (= (table ["5cm" "5cm"] [[{:foo "bar"} "a" "b"] ["c" "d"]])
    381. 

  381.          #clojure.data.xml.Element{
    382. 

  382.            :tag :fo:table
    383. 

  383.            :attrs {:border-width "0.5pt"}
    384. 

  384.            :content
    385. 

  385.              (#clojure.data.xml.Element{
    386. 

  386.                :tag :fo:table-column
    387. 

  387.                :attrs {:column-width "5cm"}
    388. 

  388.                :content ()}
    389. 

  389.               #clojure.data.xml.Element{
    390. 

  390.                :tag :fo:table-column
    391. 

  391.                :attrs {:column-width "5cm"}
    392. 

  392.                :content ()}
    393. 

  393.               #clojure.data.xml.Element{
    394. 

  394.                 :tag :fo:table-body
    395. 

  395.                 :attrs {}
    396. 

  396.                 :content
    397. 

  397.                   (#clojure.data.xml.Element{
    398. 

  398.                     :tag :fo:table-row
    399. 

  399.                     :attrs {:foo "bar"}
    400. 

  400.                     :content
    401. 

  401.                       (#clojure.data.xml.Element{
    402. 

  402.                         :tag :fo:table-cell
    403. 

  403.                         :attrs {}
    404. 

  404.                         :content
    405. 

  405.                           (#clojure.data.xml.Element{
    406. 

  406.                             :tag :fo:block
    407. 

  407.                             :attrs {:text-align "left"
    408. 

  408.                                     :font-size "10pt"
    409. 

  409.                                     :line-height "14pt"}
    410. 

  410.                                     :content ("a")})}
    411. 

  411.                        #clojure.data.xml.Element{
    412. 

  412.                         :tag :fo:table-cell
    413. 

  413.                         :attrs {}
    414. 

  414.                         :content
    415. 

  415.                           (#clojure.data.xml.Element{
    416. 

  416.                             :tag :fo:block
    417. 

  417.                             :attrs {:text-align "left"
    418. 

  418.                                     :font-size "10pt"
    419. 

  419.                                     :line-height "14pt"}
    420. 

  420.                                     :content ("b")})})}
    421. 

  421.                    #clojure.data.xml.Element{
    422. 

  422.                     :tag :fo:table-row
    423. 

  423.                     :attrs {}
    424. 

  424.                     :content
    425. 

  425.                       (#clojure.data.xml.Element{
    426. 

  426.                         :tag :fo:table-cell
    427. 

  427.                         :attrs {}
    428. 

  428.                         :content
    429. 

  429.                           (#clojure.data.xml.Element{
    430. 

  430.                             :tag :fo:block
    431. 

  431.                             :attrs {:text-align "left"
    432. 

  432.                                     :font-size "10pt"
    433. 

  433.                                     :line-height "14pt"}
    434. 

  434.                                     :content ("c")})}
    435. 

  435.                        #clojure.data.xml.Element{
    436. 

  436.                         :tag :fo:table-cell
    437. 

  437.                         :attrs {}
    438. 

  438.                         :content
    439. 

  439.                           (#clojure.data.xml.Element{
    440. 

  440.                             :tag :fo:block
    441. 

  441.                             :attrs {:text-align "left"
    442. 

  442.                                     :font-size "10pt"
    443. 

  443.                                     :line-height "14pt"}
    444. 

  444.                                     :content ("d")})})})})})))
    445. 

  445. 

  446. (deftest test-region
    447. 

  447.   (is (= (region :static-content "xsl-region-before")
    448. 

  448.          (header)
    449. 

  449.          #clojure.data.xml.Element{:tag :fo:static-content
    450. 

  450.                                    :attrs {:flow-name "xsl-region-before"}
    451. 

  451.                                    :content ()}))
    452. 

  452.   (is (= (region :static-content "xsl-region-before" (block "A") (block "B"))
    453. 

  453.          (header (block "A") (block "B"))
    454. 

  454.          #clojure.data.xml.Element{:tag :fo:static-content
    455. 

  455.                                    :attrs {:flow-name "xsl-region-before"}
    456. 

  456.                                    :content
    457. 

  457.                                    (#clojure.data.xml.Element{
    458. 

  458.                                       :tag :fo:block
    459. 

  459.                                       :attrs {:text-align "left"
    460. 

  460.                                               :font-size "10pt"
    461. 

  461.                                               :line-height "14pt"}
    462. 

  462.                                       :content ("A")}
    463. 

  463.                                     #clojure.data.xml.Element{
    464. 

  464.                                       :tag :fo:block
    465. 

  465.                                       :attrs {:text-align "left"
    466. 

  466.                                               :font-size "10pt"
    467. 

  467.                                               :line-height "14pt"}
    468. 

  468.                                               :content ("B")})}))
    469. 

  469.   (is (= (region :static-content "xsl-region-after")
    470. 

  470.          (footer)
    471. 

  471.          #clojure.data.xml.Element{:tag :fo:static-content
    472. 

  472.                                    :attrs {:flow-name "xsl-region-after"}
    473. 

  473.                                    :content ()}))
    474. 

  474.   (is (= (region :static-content "xsl-region-after" (block "A") (block "B"))
    475. 

  475.          (footer (block "A") (block "B"))
    476. 

  476.          #clojure.data.xml.Element{:tag :fo:static-content
    477. 

  477.                                    :attrs {:flow-name "xsl-region-after"}
    478. 

  478.                                    :content
    479. 

  479.                                    (#clojure.data.xml.Element{
    480. 

  480.                                       :tag :fo:block
    481. 

  481.                                       :attrs {:text-align "left"
    482. 

  482.                                               :font-size "10pt"
    483. 

  483.                                               :line-height "14pt"}
    484. 

  484.                                       :content ("A")}
    485. 

  485.                                     #clojure.data.xml.Element{
    486. 

  486.                                       :tag :fo:block
    487. 

  487.                                       :attrs {:text-align "left"
    488. 

  488.                                               :font-size "10pt"
    489. 

  489.                                               :line-height "14pt"}
    490. 

  490.                                       :content ("B")})}))
    491. 

  491.   (is (= (region :flow "xsl-region-body")
    492. 

  492.          (body)
    493. 

  493.          #clojure.data.xml.Element{:tag :fo:flow
    494. 

  494.                                    :attrs {:flow-name "xsl-region-body"}
    495. 

  495.                                    :content ()}))
    496. 

  496.   (is (= (region :flow "xsl-region-body" (block "A") (block "B"))
    497. 

  497.          (body (block "A") (block "B"))
    498. 

  498.          #clojure.data.xml.Element{:tag :fo:flow
    499. 

  499.                                    :attrs {:flow-name "xsl-region-body"}
    500. 

  500.                                    :content
    501. 

  501.                                    (#clojure.data.xml.Element{
    502. 

  502.                                       :tag :fo:block
    503. 

  503.                                       :attrs {:text-align "left"
    504. 

  504.                                               :font-size "10pt"
    505. 

  505.                                               :line-height "14pt"}
    506. 

  506.                                       :content ("A")}
    507. 

  507.                                     #clojure.data.xml.Element{
    508. 

  508.                                       :tag :fo:block
    509. 

  509.                                       :attrs {:text-align "left"
    510. 

  510.                                               :font-size "10pt"
    511. 

  511.                                               :line-height "14pt"}
    512. 

  512.                                               :content ("B")})})))
    513. 

  513. 

  514. (deftest test-document
    515. 

  515.   (is (= (slurp "resources/fo/dummy-invoice.fo")
    516. 

  516.          (xml/indent-str
    517. 

  517.           (document {:header-blocks (map #(block {:text-align "end"} %)
    518. 

  518.                                          ["Telephone: +31 (0)6 48012240"
    519. 

  519.                                           "Street: IJskelderstraat 30"
    520. 

  520.                                           "Postal code: 5046 NK"
    521. 

  521.                                           "City: Tilburg"
    522. 

  522.                                           "Chamber of Commerce: 18068751"
    523. 

  523.                                           "VAT: 1903.14.849.B01"
    524. 

  524.                                           "Bank: Rabobank 3285.04.165"])}
    525. 

  525.                     (block {:font-size "35pt"
    526. 

  526.                             :space-before.optimum "0pt"
    527. 

  527.                             :space-after.optimum "15pt"}
    528. 

  528.                            "Vixu.com")
    529. 

  529.                     (block {:space-before.optimum "100pt"
    530. 

  530.                             :space-after.optimum "20pt"}
    531. 

  531.                            (map block ["BigCo"
    532. 

  532.                                        "Mr. John Doe"
    533. 

  533.                                        "Harteveltstraat 1"
    534. 

  534.                                        "2586 EL  Den Haag"
    535. 

  535.                                        "The Netherlands"]))
    536. 

  536.                     (block {:font-weight "bold"
    537. 

  537.                             :font-size "16"
    538. 

  538.                             :space-after.optimum "20pt"}
    539. 

  539.                            "Invoice")
    540. 

  540.                     (table {:border-width "0.5pt" :space-after.optimum "30pt"}
    541. 

  541.                            ["4cm" "5cm"]
    542. 

  542.                            [["Date:" "05/02/2012"]
    543. 

  543.                             ["Invoice number:" "BAZ01"]])
    544. 

  544.                     (table {:border-width "0.5pt"}
    545. 

  545.                            ["14cm" "3cm"]
    546. 

  546.                            [[(str "Vixu.com basic subscription from "
    547. 

  547.                                   "March 1st 2012 to March 1st 2013:")
    548. 

  548.                              (block {:text-align "right"} "€ 1188.00")]
    549. 

  549.                             ["Discount (10%):"
    550. 

  550.                              (block {:text-align "right"} "- € 118.80")]
    551. 

  551.                             ["Subtotal:"
    552. 

  552.                              (block {:text-align "right"} "€ 1070.00")]
    553. 

  553.                             ["Value Added Tax (19%):"
    554. 

  554.                              (block {:text-align "right"} "€ 203.30")]
    555. 

  555.                             [{:font-weight "bold"}
    556. 

  556.                              "Total:"
    557. 

  557.                              (block {:text-align "right"} "€ 1273.30")]])
    558. 

  558.                     (block {:space-before.optimum "35pt"}
    559. 

  559.                            (str "You are kindly requested to pay within 7 days. "
    560. 

  560.                                 "Please wire the amount due to Rabobank account "
    561. 

  561.                                 "number 3285.04.165.")))))))
    562. 

  562. 

  563. (deftest test-write-pdf!
    564. 

  564.   (let [filename (temp-pdf-filename)]
    565. 

  565.     (do
    566. 

  566.       (write-pdf!
    567. 

  567.        (document {}
    568. 

  568.                  (block {:font-size "35pt"
    569. 

  569.                          :space-before.optimum "0pt"
    570. 

  570.                          :space-after.optimum "15pt"}
    571. 

  571.                         "Vixu.com"))
    572. 

  572.        filename))
    573. 

  573.     (is (= (.getText (PDFTextStripper.)
    574. 

  574.                      (PDDocument/load
    575. 

  575.                       (File. filename)))
    576. 

  576.            "Vixu.com\n"))))
    577. 

  577.