Merge branch 'subtree'
[fanfix.git] / src / be / nikiroo / fanfix / supported / BasicSupportPara.java
... / ...
CommitLineData
1package be.nikiroo.fanfix.supported;
2
3import java.io.BufferedReader;
4import java.io.ByteArrayInputStream;
5import java.io.IOException;
6import java.io.InputStreamReader;
7import java.net.URL;
8import java.util.ArrayList;
9import java.util.List;
10
11import be.nikiroo.fanfix.Instance;
12import be.nikiroo.fanfix.bundles.Config;
13import be.nikiroo.fanfix.bundles.StringId;
14import be.nikiroo.fanfix.data.Chapter;
15import be.nikiroo.fanfix.data.Paragraph;
16import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
17import be.nikiroo.utils.Image;
18import be.nikiroo.utils.Progress;
19import be.nikiroo.utils.StringUtils;
20
21/**
22 * Helper class for {@link BasicSupport}, mostly dedicated to {@link Paragraph}
23 * and text formating for the {@link BasicSupport} class.
24 *
25 * @author niki
26 */
27public class BasicSupportPara {
28 // quote chars
29 private static char openQuote = Instance.getInstance().getTrans().getCharacter(StringId.OPEN_SINGLE_QUOTE);
30 private static char closeQuote = Instance.getInstance().getTrans().getCharacter(StringId.CLOSE_SINGLE_QUOTE);
31 private static char openDoubleQuote = Instance.getInstance().getTrans().getCharacter(StringId.OPEN_DOUBLE_QUOTE);
32 private static char closeDoubleQuote = Instance.getInstance().getTrans().getCharacter(StringId.CLOSE_DOUBLE_QUOTE);
33
34 // used by this class:
35 BasicSupportHelper bsHelper;
36 BasicSupportImages bsImages;
37
38 public BasicSupportPara(BasicSupportHelper bsHelper, BasicSupportImages bsImages) {
39 this.bsHelper = bsHelper;
40 this.bsImages = bsImages;
41 }
42
43 /**
44 * Create a {@link Chapter} object from the given information, formatting
45 * the content as it should be.
46 *
47 * @param support
48 * the linked {@link BasicSupport}
49 * @param source
50 * the source of the story (for image lookup in the same path if
51 * the source is a file, can be NULL)
52 * @param number
53 * the chapter number
54 * @param name
55 * the chapter name
56 * @param content
57 * the chapter content
58 * @param pg
59 * the optional progress reporter
60 * @param html
61 * TRUE if the input content is in HTML mode
62 *
63 * @return the {@link Chapter}
64 *
65 * @throws IOException
66 * in case of I/O error
67 */
68 public Chapter makeChapter(BasicSupport support, URL source,
69 int number, String name, String content, boolean html, Progress pg)
70 throws IOException {
71 // Chapter name: process it correctly, then remove the possible
72 // redundant "Chapter x: " in front of it, or "-" (as in
73 // "Chapter 5: - Fun!" after the ": " was automatically added)
74 String chapterName = processPara(name, false)
75 .getContent().trim();
76 for (String lang : Instance.getInstance().getConfig().getList(Config.CONF_CHAPTER)) {
77 String chapterWord = Instance.getInstance().getConfig().getStringX(Config.CONF_CHAPTER, lang);
78 if (chapterName.startsWith(chapterWord)) {
79 chapterName = chapterName.substring(chapterWord.length())
80 .trim();
81 break;
82 }
83 }
84
85 if (chapterName.startsWith(Integer.toString(number))) {
86 chapterName = chapterName.substring(
87 Integer.toString(number).length()).trim();
88 }
89
90 while (chapterName.startsWith(":") || chapterName.startsWith("-")) {
91 chapterName = chapterName.substring(1).trim();
92 }
93 //
94
95 Chapter chap = new Chapter(number, chapterName);
96
97 if (content != null) {
98 List<Paragraph> paras = makeParagraphs(support, source, content,
99 html, pg);
100 long words = 0;
101 for (Paragraph para : paras) {
102 words += para.getWords();
103 }
104 chap.setParagraphs(paras);
105 chap.setWords(words);
106 }
107
108 return chap;
109 }
110
111 /**
112 * Check quotes for bad format (i.e., quotes with normal paragraphs inside)
113 * and requotify them (i.e., separate them into QUOTE paragraphs and other
114 * paragraphs (quotes or not)).
115 *
116 * @param para
117 * the paragraph to requotify (not necessarily a quote)
118 * @param html
119 * TRUE if the input content is in HTML mode
120 *
121 * @return the correctly (or so we hope) quotified paragraphs
122 */
123 protected List<Paragraph> requotify(Paragraph para, boolean html) {
124 List<Paragraph> newParas = new ArrayList<Paragraph>();
125
126 if (para.getType() == ParagraphType.QUOTE
127 && para.getContent().length() > 2) {
128 String line = para.getContent();
129 boolean singleQ = line.startsWith("" + openQuote);
130 boolean doubleQ = line.startsWith("" + openDoubleQuote);
131
132 // Do not try when more than one quote at a time
133 // (some stories are not easily readable if we do)
134 if (singleQ
135 && line.indexOf(closeQuote, 1) < line
136 .lastIndexOf(closeQuote)) {
137 newParas.add(para);
138 return newParas;
139 }
140 if (doubleQ
141 && line.indexOf(closeDoubleQuote, 1) < line
142 .lastIndexOf(closeDoubleQuote)) {
143 newParas.add(para);
144 return newParas;
145 }
146 //
147
148 if (!singleQ && !doubleQ) {
149 line = openDoubleQuote + line + closeDoubleQuote;
150 newParas.add(new Paragraph(ParagraphType.QUOTE, line, para
151 .getWords()));
152 } else {
153 char open = singleQ ? openQuote : openDoubleQuote;
154 char close = singleQ ? closeQuote : closeDoubleQuote;
155
156 int posDot = -1;
157 boolean inQuote = false;
158 int i = 0;
159 for (char car : line.toCharArray()) {
160 if (car == open) {
161 inQuote = true;
162 } else if (car == close) {
163 inQuote = false;
164 } else if (car == '.' && !inQuote) {
165 posDot = i;
166 break;
167 }
168 i++;
169 }
170
171 if (posDot >= 0) {
172 String rest = line.substring(posDot + 1).trim();
173 line = line.substring(0, posDot + 1).trim();
174 long words = 1;
175 for (char car : line.toCharArray()) {
176 if (car == ' ') {
177 words++;
178 }
179 }
180 newParas.add(new Paragraph(ParagraphType.QUOTE, line, words));
181 if (!rest.isEmpty()) {
182 newParas.addAll(requotify(processPara(rest, html), html));
183 }
184 } else {
185 newParas.add(para);
186 }
187 }
188 } else {
189 newParas.add(para);
190 }
191
192 return newParas;
193 }
194
195 /**
196 * Process a {@link Paragraph} from a raw line of text.
197 * <p>
198 * Will also fix quotes and HTML encoding if needed.
199 *
200 * @param line
201 * the raw line
202 * @param html
203 * TRUE if the input content is in HTML mode
204 *
205 * @return the processed {@link Paragraph}
206 */
207 protected Paragraph processPara(String line, boolean html) {
208 if (html) {
209 line = StringUtils.unhtml(line).trim();
210 }
211 boolean space = true;
212 boolean brk = true;
213 boolean quote = false;
214 boolean tentativeCloseQuote = false;
215 char prev = '\0';
216 int dashCount = 0;
217 long words = 1;
218
219 StringBuilder builder = new StringBuilder();
220 for (char car : line.toCharArray()) {
221 if (car != '-') {
222 if (dashCount > 0) {
223 // dash, ndash and mdash: - – —
224 // currently: always use mdash
225 builder.append(dashCount == 1 ? '-' : '—');
226 }
227 dashCount = 0;
228 }
229
230 if (tentativeCloseQuote) {
231 tentativeCloseQuote = false;
232 if (Character.isLetterOrDigit(car)) {
233 builder.append("'");
234 } else {
235 // handle double-single quotes as double quotes
236 if (prev == car) {
237 builder.append(closeDoubleQuote);
238 continue;
239 }
240
241 builder.append(closeQuote);
242 }
243 }
244
245 switch (car) {
246 case ' ': // note: unbreakable space
247 case ' ':
248 case '\t':
249 case '\n': // just in case
250 case '\r': // just in case
251 if (builder.length() > 0
252 && builder.charAt(builder.length() - 1) != ' ') {
253 words++;
254 }
255 builder.append(' ');
256 break;
257
258 case '\'':
259 if (space || (brk && quote)) {
260 quote = true;
261 // handle double-single quotes as double quotes
262 if (prev == car) {
263 builder.deleteCharAt(builder.length() - 1);
264 builder.append(openDoubleQuote);
265 } else {
266 builder.append(openQuote);
267 }
268 } else if (prev == ' ' || prev == car) {
269 // handle double-single quotes as double quotes
270 if (prev == car) {
271 builder.deleteCharAt(builder.length() - 1);
272 builder.append(openDoubleQuote);
273 } else {
274 builder.append(openQuote);
275 }
276 } else {
277 // it is a quote ("I'm off") or a 'quote' ("This
278 // 'good' restaurant"...)
279 tentativeCloseQuote = true;
280 }
281 break;
282
283 case '"':
284 if (space || (brk && quote)) {
285 quote = true;
286 builder.append(openDoubleQuote);
287 } else if (prev == ' ') {
288 builder.append(openDoubleQuote);
289 } else {
290 builder.append(closeDoubleQuote);
291 }
292 break;
293
294 case '-':
295 if (space) {
296 quote = true;
297 } else {
298 dashCount++;
299 }
300 space = false;
301 break;
302
303 case '*':
304 case '~':
305 case '/':
306 case '\\':
307 case '<':
308 case '>':
309 case '=':
310 case '+':
311 case '_':
312 case '–':
313 case '—':
314 space = false;
315 builder.append(car);
316 break;
317
318 case '‘':
319 case '`':
320 case '‹':
321 case '﹁':
322 case '〈':
323 case '「':
324 if (space || (brk && quote)) {
325 quote = true;
326 builder.append(openQuote);
327 } else {
328 // handle double-single quotes as double quotes
329 if (prev == car) {
330 builder.deleteCharAt(builder.length() - 1);
331 builder.append(openDoubleQuote);
332 } else {
333 builder.append(openQuote);
334 }
335 }
336 space = false;
337 brk = false;
338 break;
339
340 case '’':
341 case '›':
342 case '﹂':
343 case '〉':
344 case '」':
345 space = false;
346 brk = false;
347 // handle double-single quotes as double quotes
348 if (prev == car) {
349 builder.deleteCharAt(builder.length() - 1);
350 builder.append(closeDoubleQuote);
351 } else {
352 builder.append(closeQuote);
353 }
354 break;
355
356 case '«':
357 case '“':
358 case '﹃':
359 case '《':
360 case '『':
361 if (space || (brk && quote)) {
362 quote = true;
363 builder.append(openDoubleQuote);
364 } else {
365 builder.append(openDoubleQuote);
366 }
367 space = false;
368 brk = false;
369 break;
370
371 case '»':
372 case '”':
373 case '﹄':
374 case '》':
375 case '』':
376 space = false;
377 brk = false;
378 builder.append(closeDoubleQuote);
379 break;
380
381 default:
382 space = false;
383 brk = false;
384 builder.append(car);
385 break;
386 }
387
388 prev = car;
389 }
390
391 if (tentativeCloseQuote) {
392 tentativeCloseQuote = false;
393 builder.append(closeQuote);
394 }
395
396 line = builder.toString().trim();
397
398 ParagraphType type = ParagraphType.NORMAL;
399 if (space) {
400 type = ParagraphType.BLANK;
401 } else if (brk) {
402 type = ParagraphType.BREAK;
403 } else if (quote) {
404 type = ParagraphType.QUOTE;
405 }
406
407 return new Paragraph(type, line, words);
408 }
409
410 /**
411 * Convert the given content into {@link Paragraph}s.
412 *
413 * @param support
414 * the linked {@link BasicSupport} (can be NULL), used to
415 * download optional image content in []
416 * @param source
417 * the source URL of the story (for image lookup in the same path
418 * if the source is a file, can be NULL)
419 * @param content
420 * the textual content
421 * @param html
422 * TRUE if the input content is in HTML mode
423 * @param pg
424 * the optional progress reporter
425 *
426 * @return the {@link Paragraph}s
427 *
428 * @throws IOException
429 * in case of I/O error
430 */
431 protected List<Paragraph> makeParagraphs(BasicSupport support,
432 URL source, String content, boolean html, Progress pg)
433 throws IOException {
434 if (pg == null) {
435 pg = new Progress();
436 }
437
438 if (html) {
439 // Special <HR> processing:
440 content = content.replaceAll("(<hr [^>]*>)|(<hr/>)|(<hr>)",
441 "<br/>* * *<br/>");
442 }
443
444 List<Paragraph> paras = new ArrayList<Paragraph>();
445
446 if (content != null && !content.trim().isEmpty()) {
447 if (html) {
448 String[] tab = content.split("(<p>|</p>|<br>|<br/>)");
449 pg.setMinMax(0, tab.length);
450 int i = 1;
451 for (String line : tab) {
452 if (line.startsWith("[") && line.endsWith("]")) {
453 pg.setName("Extracting image " + i);
454 }
455 paras.add(makeParagraph(support, source, line.trim(), html));
456 pg.setProgress(i++);
457 }
458 } else {
459 List<String> lines = new ArrayList<String>();
460 BufferedReader buff = null;
461 try {
462 buff = new BufferedReader(
463 new InputStreamReader(new ByteArrayInputStream(
464 content.getBytes("UTF-8")), "UTF-8"));
465 for (String line = buff.readLine(); line != null; line = buff
466 .readLine()) {
467 lines.add(line.trim());
468 }
469 } finally {
470 if (buff != null) {
471 buff.close();
472 }
473 }
474
475 pg.setMinMax(0, lines.size());
476 int i = 0;
477 for (String line : lines) {
478 if (line.startsWith("[") && line.endsWith("]")) {
479 pg.setName("Extracting image " + i);
480 }
481 paras.add(makeParagraph(support, source, line, html));
482 pg.setProgress(i++);
483 }
484 }
485
486 pg.done();
487 pg.setName(null);
488
489 // Check quotes for "bad" format
490 List<Paragraph> newParas = new ArrayList<Paragraph>();
491 for (Paragraph para : paras) {
492 newParas.addAll(requotify(para, html));
493 }
494 paras = newParas;
495
496 // Remove double blanks/brks
497 fixBlanksBreaks(paras);
498 }
499
500 return paras;
501 }
502
503 /**
504 * Convert the given line into a single {@link Paragraph}.
505 *
506 * @param support
507 * the linked {@link BasicSupport} (can be NULL), used to
508 * download optional image content in []
509 * @param source
510 * the source URL of the story (for image lookup in the same path
511 * if the source is a file, can be NULL)
512 * @param line
513 * the textual content of the paragraph
514 * @param html
515 * TRUE if the input content is in HTML mode
516 *
517 * @return the {@link Paragraph}
518 */
519 protected Paragraph makeParagraph(BasicSupport support, URL source,
520 String line, boolean html) {
521 Image image = null;
522 if (line.startsWith("[") && line.endsWith("]")) {
523 image = bsHelper.getImage(support, source, line
524 .substring(1, line.length() - 1).trim());
525 }
526
527 if (image != null) {
528 return new Paragraph(image);
529 }
530
531 return processPara(line, html);
532 }
533
534 /**
535 * Fix the {@link ParagraphType#BLANK}s and {@link ParagraphType#BREAK}s of
536 * those {@link Paragraph}s.
537 * <p>
538 * The resulting list will not contain a starting or trailing blank/break
539 * nor 2 blanks or breaks following each other.
540 *
541 * @param paras
542 * the list of {@link Paragraph}s to fix
543 */
544 protected void fixBlanksBreaks(List<Paragraph> paras) {
545 boolean space = false;
546 boolean brk = true;
547 for (int i = 0; i < paras.size(); i++) {
548 Paragraph para = paras.get(i);
549 boolean thisSpace = para.getType() == ParagraphType.BLANK;
550 boolean thisBrk = para.getType() == ParagraphType.BREAK;
551
552 if (i > 0 && space && thisBrk) {
553 paras.remove(i - 1);
554 i--;
555 } else if ((space || brk) && (thisSpace || thisBrk)) {
556 paras.remove(i);
557 i--;
558 }
559
560 space = thisSpace;
561 brk = thisBrk;
562 }
563
564 // Remove blank/brk at start
565 if (paras.size() > 0
566 && (paras.get(0).getType() == ParagraphType.BLANK || paras.get(
567 0).getType() == ParagraphType.BREAK)) {
568 paras.remove(0);
569 }
570
571 // Remove blank/brk at end
572 int last = paras.size() - 1;
573 if (paras.size() > 0
574 && (paras.get(last).getType() == ParagraphType.BLANK || paras
575 .get(last).getType() == ParagraphType.BREAK)) {
576 paras.remove(last);
577 }
578 }
579}