fix changelog headers
[fanfix.git] / BasicSupport.java
... / ...
CommitLineData
1package be.nikiroo.fanfix.supported;
2
3import java.awt.image.BufferedImage;
4import java.io.BufferedReader;
5import java.io.ByteArrayInputStream;
6import java.io.File;
7import java.io.IOException;
8import java.io.InputStream;
9import java.io.InputStreamReader;
10import java.net.MalformedURLException;
11import java.net.URL;
12import java.util.ArrayList;
13import java.util.Date;
14import java.util.HashMap;
15import java.util.List;
16import java.util.Map;
17import java.util.Map.Entry;
18import java.util.Scanner;
19
20import be.nikiroo.fanfix.Instance;
21import be.nikiroo.fanfix.bundles.Config;
22import be.nikiroo.fanfix.bundles.StringId;
23import be.nikiroo.fanfix.data.Chapter;
24import be.nikiroo.fanfix.data.MetaData;
25import be.nikiroo.fanfix.data.Paragraph;
26import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
27import be.nikiroo.fanfix.data.Story;
28import be.nikiroo.utils.ImageUtils;
29import be.nikiroo.utils.Progress;
30import be.nikiroo.utils.StringUtils;
31
32/**
33 * This class is the base class used by the other support classes. It can be
34 * used outside of this package, and have static method that you can use to get
35 * access to the correct support class.
36 * <p>
37 * It will be used with 'resources' (usually web pages or files).
38 *
39 * @author niki
40 */
41public abstract class BasicSupport {
42 /**
43 * The supported input types for which we can get a {@link BasicSupport}
44 * object.
45 *
46 * @author niki
47 */
48 public enum SupportType {
49 /** EPUB files created with this program */
50 EPUB,
51 /** Pure text file with some rules */
52 TEXT,
53 /** TEXT but with associated .info file */
54 INFO_TEXT,
55 /** My Little Pony fanfictions */
56 FIMFICTION,
57 /** Fanfictions from a lot of different universes */
58 FANFICTION,
59 /** Website with lots of Mangas */
60 MANGAFOX,
61 /** Furry website with comics support */
62 E621,
63 /** Furry website with stories */
64 YIFFSTAR,
65 /** Comics and images groups, mostly but not only NSFW */
66 E_HENTAI,
67 /** CBZ files */
68 CBZ,
69 /** HTML files */
70 HTML;
71
72 /**
73 * A description of this support type (more information than the
74 * {@link BasicSupport#getSourceName()}).
75 *
76 * @return the description
77 */
78 public String getDesc() {
79 String desc = Instance.getTrans().getStringX(StringId.INPUT_DESC,
80 this.name());
81
82 if (desc == null) {
83 desc = Instance.getTrans().getString(StringId.INPUT_DESC, this);
84 }
85
86 return desc;
87 }
88
89 /**
90 * The name of this support type (a short version).
91 *
92 * @return the name
93 */
94 public String getSourceName() {
95 BasicSupport support = BasicSupport.getSupport(this);
96 if (support != null) {
97 return support.getSourceName();
98 }
99
100 return null;
101 }
102
103 @Override
104 public String toString() {
105 return super.toString().toLowerCase();
106 }
107
108 /**
109 * Call {@link SupportType#valueOf(String)} after conversion to upper
110 * case.
111 *
112 * @param typeName
113 * the possible type name
114 *
115 * @return NULL or the type
116 */
117 public static SupportType valueOfUC(String typeName) {
118 return SupportType.valueOf(typeName == null ? null : typeName
119 .toUpperCase());
120 }
121
122 /**
123 * Call {@link SupportType#valueOf(String)} after conversion to upper
124 * case but return NULL for NULL instead of raising exception.
125 *
126 * @param typeName
127 * the possible type name
128 *
129 * @return NULL or the type
130 */
131 public static SupportType valueOfNullOkUC(String typeName) {
132 if (typeName == null) {
133 return null;
134 }
135
136 return SupportType.valueOfUC(typeName);
137 }
138
139 /**
140 * Call {@link SupportType#valueOf(String)} after conversion to upper
141 * case but return NULL in case of error instead of raising an
142 * exception.
143 *
144 * @param typeName
145 * the possible type name
146 *
147 * @return NULL or the type
148 */
149 public static SupportType valueOfAllOkUC(String typeName) {
150 try {
151 return SupportType.valueOfUC(typeName);
152 } catch (Exception e) {
153 return null;
154 }
155 }
156 }
157
158 private InputStream in;
159 private SupportType type;
160 private URL currentReferer; // with only one 'r', as in 'HTTP'...
161
162 // quote chars
163 private char openQuote = Instance.getTrans().getCharacter(
164 StringId.OPEN_SINGLE_QUOTE);
165 private char closeQuote = Instance.getTrans().getCharacter(
166 StringId.CLOSE_SINGLE_QUOTE);
167 private char openDoubleQuote = Instance.getTrans().getCharacter(
168 StringId.OPEN_DOUBLE_QUOTE);
169 private char closeDoubleQuote = Instance.getTrans().getCharacter(
170 StringId.CLOSE_DOUBLE_QUOTE);
171
172 /**
173 * The name of this support class.
174 *
175 * @return the name
176 */
177 protected abstract String getSourceName();
178
179 /**
180 * Check if the given resource is supported by this {@link BasicSupport}.
181 *
182 * @param url
183 * the resource to check for
184 *
185 * @return TRUE if it is
186 */
187 protected abstract boolean supports(URL url);
188
189 /**
190 * Return TRUE if the support will return HTML encoded content values for
191 * the chapters content.
192 *
193 * @return TRUE for HTML
194 */
195 protected abstract boolean isHtml();
196
197 /**
198 * Return the {@link MetaData} of this story.
199 *
200 * @param source
201 * the source of the story
202 * @param in
203 * the input (the main resource)
204 *
205 * @return the associated {@link MetaData}
206 *
207 * @throws IOException
208 * in case of I/O error
209 */
210 protected abstract MetaData getMeta(URL source, InputStream in)
211 throws IOException;
212
213 /**
214 * Return the story description.
215 *
216 * @param source
217 * the source of the story
218 * @param in
219 * the input (the main resource)
220 *
221 * @return the description
222 *
223 * @throws IOException
224 * in case of I/O error
225 */
226 protected abstract String getDesc(URL source, InputStream in)
227 throws IOException;
228
229 /**
230 * Return the list of chapters (name and resource).
231 *
232 * @param source
233 * the source of the story
234 * @param in
235 * the input (the main resource)
236 * @param pg
237 * the optional progress reporter
238 *
239 * @return the chapters
240 *
241 * @throws IOException
242 * in case of I/O error
243 */
244 protected abstract List<Entry<String, URL>> getChapters(URL source,
245 InputStream in, Progress pg) throws IOException;
246
247 /**
248 * Return the content of the chapter (possibly HTML encoded, if
249 * {@link BasicSupport#isHtml()} is TRUE).
250 *
251 * @param source
252 * the source of the story
253 * @param in
254 * the input (the main resource)
255 * @param number
256 * the chapter number
257 * @param pg
258 * the optional progress reporter
259 *
260 * @return the content
261 *
262 * @throws IOException
263 * in case of I/O error
264 */
265 protected abstract String getChapterContent(URL source, InputStream in,
266 int number, Progress pg) throws IOException;
267
268 /**
269 * Log into the support (can be a no-op depending upon the support).
270 *
271 * @throws IOException
272 * in case of I/O error
273 */
274 @SuppressWarnings("unused")
275 public void login() throws IOException {
276 }
277
278 /**
279 * Return the list of cookies (values included) that must be used to
280 * correctly fetch the resources.
281 * <p>
282 * You are expected to call the super method implementation if you override
283 * it.
284 *
285 * @return the cookies
286 */
287 public Map<String, String> getCookies() {
288 return new HashMap<String, String>();
289 }
290
291 /**
292 * OAuth authorisation (aka, "bearer XXXXXXX").
293 *
294 * @return the OAuth string
295 */
296 public String getOAuth() {
297 return null;
298 }
299
300 /**
301 * Return the canonical form of the main {@link URL}.
302 *
303 * @param source
304 * the source {@link URL}
305 *
306 * @return the canonical form of this {@link URL}
307 *
308 * @throws IOException
309 * in case of I/O error
310 */
311 @SuppressWarnings("unused")
312 public URL getCanonicalUrl(URL source) throws IOException {
313 return source;
314 }
315
316 /**
317 * Process the given story resource into a partially filled {@link Story}
318 * object containing the name and metadata, except for the description.
319 *
320 * @param url
321 * the story resource
322 *
323 * @return the {@link Story}
324 *
325 * @throws IOException
326 * in case of I/O error
327 */
328 public Story processMeta(URL url) throws IOException {
329 return processMeta(url, true, false, null);
330 }
331
332 /**
333 * Process the given story resource into a partially filled {@link Story}
334 * object containing the name and metadata.
335 *
336 * @param url
337 * the story resource
338 * @param close
339 * close "this" and "in" when done
340 * @param getDesc
341 * retrieve the description of the story, or not
342 * @param pg
343 * the optional progress reporter
344 *
345 * @return the {@link Story}
346 *
347 * @throws IOException
348 * in case of I/O error
349 */
350 protected Story processMeta(URL url, boolean close, boolean getDesc,
351 Progress pg) throws IOException {
352 if (pg == null) {
353 pg = new Progress();
354 } else {
355 pg.setMinMax(0, 100);
356 }
357
358 login();
359 pg.setProgress(10);
360
361 url = getCanonicalUrl(url);
362
363 setCurrentReferer(url);
364
365 in = openInput(url); // NULL allowed here
366 try {
367 preprocess(url, getInput());
368 pg.setProgress(30);
369
370 Story story = new Story();
371 MetaData meta = getMeta(url, getInput());
372 if (meta.getCreationDate() == null
373 || meta.getCreationDate().isEmpty()) {
374 meta.setCreationDate(StringUtils.fromTime(new Date().getTime()));
375 }
376 story.setMeta(meta);
377
378 pg.setProgress(50);
379
380 if (meta.getCover() == null) {
381 meta.setCover(getDefaultCover(meta.getSubject()));
382 }
383
384 pg.setProgress(60);
385
386 if (getDesc) {
387 String descChapterName = Instance.getTrans().getString(
388 StringId.DESCRIPTION);
389 story.getMeta().setResume(
390 makeChapter(url, 0, descChapterName,
391 getDesc(url, getInput()), null));
392 }
393
394 pg.setProgress(100);
395 return story;
396 } finally {
397 if (close) {
398 try {
399 close();
400 } catch (IOException e) {
401 Instance.getTraceHandler().error(e);
402 }
403
404 if (in != null) {
405 in.close();
406 }
407 }
408
409 setCurrentReferer(null);
410 }
411 }
412
413 /**
414 * Process the given story resource into a fully filled {@link Story}
415 * object.
416 *
417 * @param url
418 * the story resource
419 * @param pg
420 * the optional progress reporter
421 *
422 * @return the {@link Story}
423 *
424 * @throws IOException
425 * in case of I/O error
426 */
427 public Story process(URL url, Progress pg) throws IOException {
428 if (pg == null) {
429 pg = new Progress();
430 } else {
431 pg.setMinMax(0, 100);
432 }
433
434 url = getCanonicalUrl(url);
435 pg.setProgress(1);
436 try {
437 Progress pgMeta = new Progress();
438 pg.addProgress(pgMeta, 10);
439 Story story = processMeta(url, false, true, pgMeta);
440 if (!pgMeta.isDone()) {
441 pgMeta.setProgress(pgMeta.getMax()); // 10%
442 }
443
444 if (story == null) {
445 pg.setProgress(90);
446 return null;
447 }
448
449 pg.setName("Retrieving " + story.getMeta().getTitle());
450
451 setCurrentReferer(url);
452
453 Progress pgGetChapters = new Progress();
454 pg.addProgress(pgGetChapters, 10);
455 story.setChapters(new ArrayList<Chapter>());
456 List<Entry<String, URL>> chapters = getChapters(url, getInput(),
457 pgGetChapters);
458 if (!pgGetChapters.isDone()) {
459 pgGetChapters.setProgress(pgGetChapters.getMax()); // 20%
460 }
461
462 if (chapters != null) {
463 Progress pgChaps = new Progress("Extracting chapters", 0,
464 chapters.size() * 300);
465 pg.addProgress(pgChaps, 80);
466
467 long words = 0;
468 int i = 1;
469 for (Entry<String, URL> chap : chapters) {
470 pgChaps.setName("Extracting chapter " + i);
471 InputStream chapIn = null;
472 if (chap.getValue() != null) {
473 setCurrentReferer(chap.getValue());
474 chapIn = Instance.getCache().open(chap.getValue(),
475 this, true);
476 }
477 pgChaps.setProgress(i * 100);
478 try {
479 Progress pgGetChapterContent = new Progress();
480 Progress pgMakeChapter = new Progress();
481 pgChaps.addProgress(pgGetChapterContent, 100);
482 pgChaps.addProgress(pgMakeChapter, 100);
483
484 String content = getChapterContent(url, chapIn, i,
485 pgGetChapterContent);
486 if (!pgGetChapterContent.isDone()) {
487 pgGetChapterContent.setProgress(pgGetChapterContent
488 .getMax());
489 }
490
491 Chapter cc = makeChapter(url, i, chap.getKey(),
492 content, pgMakeChapter);
493 if (!pgMakeChapter.isDone()) {
494 pgMakeChapter.setProgress(pgMakeChapter.getMax());
495 }
496
497 words += cc.getWords();
498 story.getChapters().add(cc);
499 if (story.getMeta() != null) {
500 story.getMeta().setWords(words);
501 }
502 } finally {
503 if (chapIn != null) {
504 chapIn.close();
505 }
506 }
507
508 i++;
509 }
510
511 pgChaps.setName("Extracting chapters");
512 } else {
513 pg.setProgress(80);
514 }
515
516 return story;
517
518 } finally {
519 try {
520 close();
521 } catch (IOException e) {
522 Instance.getTraceHandler().error(e);
523 }
524
525 if (in != null) {
526 in.close();
527 }
528
529 setCurrentReferer(null);
530 }
531 }
532
533 /**
534 * The support type.
535 *
536 * @return the type
537 */
538 public SupportType getType() {
539 return type;
540 }
541
542 /**
543 * The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
544 * the current {@link URL} we work on.
545 *
546 * @return the referer
547 */
548 public URL getCurrentReferer() {
549 return currentReferer;
550 }
551
552 /**
553 * The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
554 * the current {@link URL} we work on.
555 *
556 * @param currentReferer
557 * the new referer
558 */
559 protected void setCurrentReferer(URL currentReferer) {
560 this.currentReferer = currentReferer;
561 }
562
563 /**
564 * The support type.
565 *
566 * @param type
567 * the new type
568 *
569 * @return this
570 */
571 protected BasicSupport setType(SupportType type) {
572 this.type = type;
573 return this;
574 }
575
576 /**
577 * Prepare the support if needed before processing.
578 *
579 * @param source
580 * the source of the story
581 * @param in
582 * the input (the main resource)
583 *
584 * @throws IOException
585 * on I/O error
586 */
587 @SuppressWarnings("unused")
588 protected void preprocess(URL source, InputStream in) throws IOException {
589 }
590
591 /**
592 * Now that we have processed the {@link Story}, close the resources if any.
593 *
594 * @throws IOException
595 * on I/O error
596 */
597 @SuppressWarnings("unused")
598 protected void close() throws IOException {
599 }
600
601 /**
602 * Create a {@link Chapter} object from the given information, formatting
603 * the content as it should be.
604 *
605 * @param source
606 * the source of the story
607 * @param number
608 * the chapter number
609 * @param name
610 * the chapter name
611 * @param content
612 * the chapter content
613 * @param pg
614 * the optional progress reporter
615 *
616 * @return the {@link Chapter}
617 *
618 * @throws IOException
619 * in case of I/O error
620 */
621 protected Chapter makeChapter(URL source, int number, String name,
622 String content, Progress pg) throws IOException {
623 // Chapter name: process it correctly, then remove the possible
624 // redundant "Chapter x: " in front of it, or "-" (as in
625 // "Chapter 5: - Fun!" after the ": " was automatically added)
626 String chapterName = processPara(name).getContent().trim();
627 for (String lang : Instance.getConfig().getString(Config.CHAPTER)
628 .split(",")) {
629 String chapterWord = Instance.getConfig().getStringX(
630 Config.CHAPTER, lang);
631 if (chapterName.startsWith(chapterWord)) {
632 chapterName = chapterName.substring(chapterWord.length())
633 .trim();
634 break;
635 }
636 }
637
638 if (chapterName.startsWith(Integer.toString(number))) {
639 chapterName = chapterName.substring(
640 Integer.toString(number).length()).trim();
641 }
642
643 while (chapterName.startsWith(":") || chapterName.startsWith("-")) {
644 chapterName = chapterName.substring(1).trim();
645 }
646 //
647
648 Chapter chap = new Chapter(number, chapterName);
649
650 if (content != null) {
651 List<Paragraph> paras = makeParagraphs(source, content, pg);
652 long words = 0;
653 for (Paragraph para : paras) {
654 words += para.getWords();
655 }
656 chap.setParagraphs(paras);
657 chap.setWords(words);
658 }
659
660 return chap;
661
662 }
663
664 /**
665 * Convert the given content into {@link Paragraph}s.
666 *
667 * @param source
668 * the source URL of the story
669 * @param content
670 * the textual content
671 * @param pg
672 * the optional progress reporter
673 *
674 * @return the {@link Paragraph}s
675 *
676 * @throws IOException
677 * in case of I/O error
678 */
679 protected List<Paragraph> makeParagraphs(URL source, String content,
680 Progress pg) throws IOException {
681 if (pg == null) {
682 pg = new Progress();
683 }
684
685 if (isHtml()) {
686 // Special <HR> processing:
687 content = content.replaceAll("(<hr [^>]*>)|(<hr/>)|(<hr>)",
688 "<br/>* * *<br/>");
689 }
690
691 List<Paragraph> paras = new ArrayList<Paragraph>();
692
693 if (content != null && !content.trim().isEmpty()) {
694 if (isHtml()) {
695 String[] tab = content.split("(<p>|</p>|<br>|<br/>)");
696 pg.setMinMax(0, tab.length);
697 int i = 1;
698 for (String line : tab) {
699 if (line.startsWith("[") && line.endsWith("]")) {
700 pg.setName("Extracting image " + i);
701 }
702 paras.add(makeParagraph(source, line.trim()));
703 pg.setProgress(i++);
704 }
705 pg.setName(null);
706 } else {
707 List<String> lines = new ArrayList<String>();
708 BufferedReader buff = null;
709 try {
710 buff = new BufferedReader(
711 new InputStreamReader(new ByteArrayInputStream(
712 content.getBytes("UTF-8")), "UTF-8"));
713 for (String line = buff.readLine(); line != null; line = buff
714 .readLine()) {
715 lines.add(line.trim());
716 }
717 } finally {
718 if (buff != null) {
719 buff.close();
720 }
721 }
722
723 pg.setMinMax(0, lines.size());
724 int i = 0;
725 for (String line : lines) {
726 if (line.startsWith("[") && line.endsWith("]")) {
727 pg.setName("Extracting image " + i);
728 }
729 paras.add(makeParagraph(source, line));
730 pg.setProgress(i++);
731 }
732 pg.setName(null);
733 }
734
735 // Check quotes for "bad" format
736 List<Paragraph> newParas = new ArrayList<Paragraph>();
737 for (Paragraph para : paras) {
738 newParas.addAll(requotify(para));
739 }
740 paras = newParas;
741
742 // Remove double blanks/brks
743 fixBlanksBreaks(paras);
744 }
745
746 return paras;
747 }
748
749 /**
750 * Convert the given line into a single {@link Paragraph}.
751 *
752 * @param source
753 * the source URL of the story
754 * @param line
755 * the textual content of the paragraph
756 *
757 * @return the {@link Paragraph}
758 */
759 private Paragraph makeParagraph(URL source, String line) {
760 BufferedImage image = null;
761 if (line.startsWith("[") && line.endsWith("]")) {
762 image = getImage(this, source, line.substring(1, line.length() - 1)
763 .trim());
764 }
765
766 if (image != null) {
767 return new Paragraph(image);
768 }
769
770 return processPara(line);
771 }
772
773 /**
774 * Fix the {@link ParagraphType#BLANK}s and {@link ParagraphType#BREAK}s of
775 * those {@link Paragraph}s.
776 * <p>
777 * The resulting list will not contain a starting or trailing blank/break
778 * nor 2 blanks or breaks following each other.
779 *
780 * @param paras
781 * the list of {@link Paragraph}s to fix
782 */
783 protected void fixBlanksBreaks(List<Paragraph> paras) {
784 boolean space = false;
785 boolean brk = true;
786 for (int i = 0; i < paras.size(); i++) {
787 Paragraph para = paras.get(i);
788 boolean thisSpace = para.getType() == ParagraphType.BLANK;
789 boolean thisBrk = para.getType() == ParagraphType.BREAK;
790
791 if (i > 0 && space && thisBrk) {
792 paras.remove(i - 1);
793 i--;
794 } else if ((space || brk) && (thisSpace || thisBrk)) {
795 paras.remove(i);
796 i--;
797 }
798
799 space = thisSpace;
800 brk = thisBrk;
801 }
802
803 // Remove blank/brk at start
804 if (paras.size() > 0
805 && (paras.get(0).getType() == ParagraphType.BLANK || paras.get(
806 0).getType() == ParagraphType.BREAK)) {
807 paras.remove(0);
808 }
809
810 // Remove blank/brk at end
811 int last = paras.size() - 1;
812 if (paras.size() > 0
813 && (paras.get(last).getType() == ParagraphType.BLANK || paras
814 .get(last).getType() == ParagraphType.BREAK)) {
815 paras.remove(last);
816 }
817 }
818
819 /**
820 * Get the default cover related to this subject (see <tt>.info</tt> files).
821 *
822 * @param subject
823 * the subject
824 *
825 * @return the cover if any, or NULL
826 */
827 static BufferedImage getDefaultCover(String subject) {
828 if (subject != null && !subject.isEmpty()
829 && Instance.getCoverDir() != null) {
830 try {
831 File fileCover = new File(Instance.getCoverDir(), subject);
832 return getImage(null, fileCover.toURI().toURL(), subject);
833 } catch (MalformedURLException e) {
834 }
835 }
836
837 return null;
838 }
839
840 /**
841 * Return the list of supported image extensions.
842 *
843 * @param emptyAllowed
844 * TRUE to allow an empty extension on first place, which can be
845 * used when you may already have an extension in your input but
846 * are not sure about it
847 *
848 * @return the extensions
849 */
850 static String[] getImageExt(boolean emptyAllowed) {
851 if (emptyAllowed) {
852 return new String[] { "", ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
853 }
854
855 return new String[] { ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
856 }
857
858 /**
859 * Check if the given resource can be a local image or a remote image, then
860 * refresh the cache with it if it is.
861 *
862 * @param source
863 * the story source
864 * @param line
865 * the resource to check
866 *
867 * @return the image if found, or NULL
868 *
869 */
870 static BufferedImage getImage(BasicSupport support, URL source, String line) {
871 URL url = getImageUrl(support, source, line);
872 if (url != null) {
873 InputStream in = null;
874 try {
875 in = Instance.getCache().open(url, getSupport(url), true);
876 return ImageUtils.fromStream(in);
877 } catch (IOException e) {
878 } finally {
879 if (in != null) {
880 try {
881 in.close();
882 } catch (IOException e) {
883 }
884 }
885 }
886 }
887
888 return null;
889 }
890
891 /**
892 * Check if the given resource can be a local image or a remote image, then
893 * refresh the cache with it if it is.
894 *
895 * @param source
896 * the story source
897 * @param line
898 * the resource to check
899 *
900 * @return the image URL if found, or NULL
901 *
902 */
903 static URL getImageUrl(BasicSupport support, URL source, String line) {
904 URL url = null;
905
906 if (line != null) {
907 // try for files
908 if (source != null) {
909 try {
910
911 String relPath = null;
912 String absPath = null;
913 try {
914 String path = new File(source.getFile()).getParent();
915 relPath = new File(new File(path), line.trim())
916 .getAbsolutePath();
917 } catch (Exception e) {
918 // Cannot be converted to path (one possibility to take
919 // into account: absolute path on Windows)
920 }
921 try {
922 absPath = new File(line.trim()).getAbsolutePath();
923 } catch (Exception e) {
924 // Cannot be converted to path (at all)
925 }
926
927 for (String ext : getImageExt(true)) {
928 if (absPath != null && new File(absPath + ext).exists()) {
929 url = new File(absPath + ext).toURI().toURL();
930 } else if (relPath != null
931 && new File(relPath + ext).exists()) {
932 url = new File(relPath + ext).toURI().toURL();
933 }
934 }
935 } catch (Exception e) {
936 // Should not happen since we control the correct arguments
937 }
938 }
939
940 if (url == null) {
941 // try for URLs
942 try {
943 for (String ext : getImageExt(true)) {
944 if (Instance.getCache()
945 .check(new URL(line + ext), true)) {
946 url = new URL(line + ext);
947 break;
948 }
949 }
950
951 // try out of cache
952 if (url == null) {
953 for (String ext : getImageExt(true)) {
954 try {
955 url = new URL(line + ext);
956 Instance.getCache().refresh(url, support, true);
957 break;
958 } catch (IOException e) {
959 // no image with this ext
960 url = null;
961 }
962 }
963 }
964 } catch (MalformedURLException e) {
965 // Not an url
966 }
967 }
968
969 // refresh the cached file
970 if (url != null) {
971 try {
972 Instance.getCache().refresh(url, support, true);
973 } catch (IOException e) {
974 // woops, broken image
975 url = null;
976 }
977 }
978 }
979
980 return url;
981 }
982
983 /**
984 * Open the input file that will be used through the support.
985 * <p>
986 * Can return NULL, in which case you are supposed to work without an
987 * {@link InputStream}.
988 *
989 * @param source
990 * the source {@link URL}
991 *
992 * @return the {@link InputStream}
993 *
994 * @throws IOException
995 * in case of I/O error
996 */
997 protected InputStream openInput(URL source) throws IOException {
998 return Instance.getCache().open(source, this, false);
999 }
1000
1001 /**
1002 * Reset then return {@link BasicSupport#in}.
1003 *
1004 * @return {@link BasicSupport#in}
1005 */
1006 protected InputStream getInput() {
1007 return reset(in);
1008 }
1009
1010 /**
1011 * Fix the author name if it is prefixed with some "by" {@link String}.
1012 *
1013 * @param author
1014 * the author with a possible prefix
1015 *
1016 * @return the author without prefixes
1017 */
1018 protected String fixAuthor(String author) {
1019 if (author != null) {
1020 for (String suffix : new String[] { " ", ":" }) {
1021 for (String byString : Instance.getConfig()
1022 .getString(Config.BYS).split(",")) {
1023 byString += suffix;
1024 if (author.toUpperCase().startsWith(byString.toUpperCase())) {
1025 author = author.substring(byString.length()).trim();
1026 }
1027 }
1028 }
1029
1030 // Special case (without suffix):
1031 if (author.startsWith("©")) {
1032 author = author.substring(1);
1033 }
1034 }
1035
1036 return author;
1037 }
1038
1039 /**
1040 * Check quotes for bad format (i.e., quotes with normal paragraphs inside)
1041 * and requotify them (i.e., separate them into QUOTE paragraphs and other
1042 * paragraphs (quotes or not)).
1043 *
1044 * @param para
1045 * the paragraph to requotify (not necessarily a quote)
1046 *
1047 * @return the correctly (or so we hope) quotified paragraphs
1048 */
1049 protected List<Paragraph> requotify(Paragraph para) {
1050 List<Paragraph> newParas = new ArrayList<Paragraph>();
1051
1052 if (para.getType() == ParagraphType.QUOTE
1053 && para.getContent().length() > 2) {
1054 String line = para.getContent();
1055 boolean singleQ = line.startsWith("" + openQuote);
1056 boolean doubleQ = line.startsWith("" + openDoubleQuote);
1057
1058 // Do not try when more than one quote at a time
1059 // (some stories are not easily readable if we do)
1060 if (singleQ
1061 && line.indexOf(closeQuote, 1) < line
1062 .lastIndexOf(closeQuote)) {
1063 newParas.add(para);
1064 return newParas;
1065 }
1066 if (doubleQ
1067 && line.indexOf(closeDoubleQuote, 1) < line
1068 .lastIndexOf(closeDoubleQuote)) {
1069 newParas.add(para);
1070 return newParas;
1071 }
1072 //
1073
1074 if (!singleQ && !doubleQ) {
1075 line = openDoubleQuote + line + closeDoubleQuote;
1076 newParas.add(new Paragraph(ParagraphType.QUOTE, line, para
1077 .getWords()));
1078 } else {
1079 char open = singleQ ? openQuote : openDoubleQuote;
1080 char close = singleQ ? closeQuote : closeDoubleQuote;
1081
1082 int posDot = -1;
1083 boolean inQuote = false;
1084 int i = 0;
1085 for (char car : line.toCharArray()) {
1086 if (car == open) {
1087 inQuote = true;
1088 } else if (car == close) {
1089 inQuote = false;
1090 } else if (car == '.' && !inQuote) {
1091 posDot = i;
1092 break;
1093 }
1094 i++;
1095 }
1096
1097 if (posDot >= 0) {
1098 String rest = line.substring(posDot + 1).trim();
1099 line = line.substring(0, posDot + 1).trim();
1100 long words = 1;
1101 for (char car : line.toCharArray()) {
1102 if (car == ' ') {
1103 words++;
1104 }
1105 }
1106 newParas.add(new Paragraph(ParagraphType.QUOTE, line, words));
1107 if (!rest.isEmpty()) {
1108 newParas.addAll(requotify(processPara(rest)));
1109 }
1110 } else {
1111 newParas.add(para);
1112 }
1113 }
1114 } else {
1115 newParas.add(para);
1116 }
1117
1118 return newParas;
1119 }
1120
1121 /**
1122 * Process a {@link Paragraph} from a raw line of text.
1123 * <p>
1124 * Will also fix quotes and HTML encoding if needed.
1125 *
1126 * @param line
1127 * the raw line
1128 *
1129 * @return the processed {@link Paragraph}
1130 */
1131 protected Paragraph processPara(String line) {
1132 line = ifUnhtml(line).trim();
1133
1134 boolean space = true;
1135 boolean brk = true;
1136 boolean quote = false;
1137 boolean tentativeCloseQuote = false;
1138 char prev = '\0';
1139 int dashCount = 0;
1140 long words = 1;
1141
1142 StringBuilder builder = new StringBuilder();
1143 for (char car : line.toCharArray()) {
1144 if (car != '-') {
1145 if (dashCount > 0) {
1146 // dash, ndash and mdash: - – —
1147 // currently: always use mdash
1148 builder.append(dashCount == 1 ? '-' : '—');
1149 }
1150 dashCount = 0;
1151 }
1152
1153 if (tentativeCloseQuote) {
1154 tentativeCloseQuote = false;
1155 if (Character.isLetterOrDigit(car)) {
1156 builder.append("'");
1157 } else {
1158 // handle double-single quotes as double quotes
1159 if (prev == car) {
1160 builder.append(closeDoubleQuote);
1161 continue;
1162 }
1163
1164 builder.append(closeQuote);
1165 }
1166 }
1167
1168 switch (car) {
1169 case ' ': // note: unbreakable space
1170 case ' ':
1171 case '\t':
1172 case '\n': // just in case
1173 case '\r': // just in case
1174 if (builder.length() > 0
1175 && builder.charAt(builder.length() - 1) != ' ') {
1176 words++;
1177 }
1178 builder.append(' ');
1179 break;
1180
1181 case '\'':
1182 if (space || (brk && quote)) {
1183 quote = true;
1184 // handle double-single quotes as double quotes
1185 if (prev == car) {
1186 builder.deleteCharAt(builder.length() - 1);
1187 builder.append(openDoubleQuote);
1188 } else {
1189 builder.append(openQuote);
1190 }
1191 } else if (prev == ' ' || prev == car) {
1192 // handle double-single quotes as double quotes
1193 if (prev == car) {
1194 builder.deleteCharAt(builder.length() - 1);
1195 builder.append(openDoubleQuote);
1196 } else {
1197 builder.append(openQuote);
1198 }
1199 } else {
1200 // it is a quote ("I'm off") or a 'quote' ("This
1201 // 'good' restaurant"...)
1202 tentativeCloseQuote = true;
1203 }
1204 break;
1205
1206 case '"':
1207 if (space || (brk && quote)) {
1208 quote = true;
1209 builder.append(openDoubleQuote);
1210 } else if (prev == ' ') {
1211 builder.append(openDoubleQuote);
1212 } else {
1213 builder.append(closeDoubleQuote);
1214 }
1215 break;
1216
1217 case '-':
1218 if (space) {
1219 quote = true;
1220 } else {
1221 dashCount++;
1222 }
1223 space = false;
1224 break;
1225
1226 case '*':
1227 case '~':
1228 case '/':
1229 case '\\':
1230 case '<':
1231 case '>':
1232 case '=':
1233 case '+':
1234 case '_':
1235 case '–':
1236 case '—':
1237 space = false;
1238 builder.append(car);
1239 break;
1240
1241 case '‘':
1242 case '`':
1243 case '‹':
1244 case '﹁':
1245 case '〈':
1246 case '「':
1247 if (space || (brk && quote)) {
1248 quote = true;
1249 builder.append(openQuote);
1250 } else {
1251 // handle double-single quotes as double quotes
1252 if (prev == car) {
1253 builder.deleteCharAt(builder.length() - 1);
1254 builder.append(openDoubleQuote);
1255 } else {
1256 builder.append(openQuote);
1257 }
1258 }
1259 space = false;
1260 brk = false;
1261 break;
1262
1263 case '’':
1264 case '›':
1265 case '﹂':
1266 case '〉':
1267 case '」':
1268 space = false;
1269 brk = false;
1270 // handle double-single quotes as double quotes
1271 if (prev == car) {
1272 builder.deleteCharAt(builder.length() - 1);
1273 builder.append(closeDoubleQuote);
1274 } else {
1275 builder.append(closeQuote);
1276 }
1277 break;
1278
1279 case '«':
1280 case '“':
1281 case '﹃':
1282 case '《':
1283 case '『':
1284 if (space || (brk && quote)) {
1285 quote = true;
1286 builder.append(openDoubleQuote);
1287 } else {
1288 builder.append(openDoubleQuote);
1289 }
1290 space = false;
1291 brk = false;
1292 break;
1293
1294 case '»':
1295 case '”':
1296 case '﹄':
1297 case '》':
1298 case '』':
1299 space = false;
1300 brk = false;
1301 builder.append(closeDoubleQuote);
1302 break;
1303
1304 default:
1305 space = false;
1306 brk = false;
1307 builder.append(car);
1308 break;
1309 }
1310
1311 prev = car;
1312 }
1313
1314 if (tentativeCloseQuote) {
1315 tentativeCloseQuote = false;
1316 builder.append(closeQuote);
1317 }
1318
1319 line = builder.toString().trim();
1320
1321 ParagraphType type = ParagraphType.NORMAL;
1322 if (space) {
1323 type = ParagraphType.BLANK;
1324 } else if (brk) {
1325 type = ParagraphType.BREAK;
1326 } else if (quote) {
1327 type = ParagraphType.QUOTE;
1328 }
1329
1330 return new Paragraph(type, line, words);
1331 }
1332
1333 /**
1334 * Remove the HTML from the input <b>if</b> {@link BasicSupport#isHtml()} is
1335 * true.
1336 *
1337 * @param input
1338 * the input
1339 *
1340 * @return the no html version if needed
1341 */
1342 private String ifUnhtml(String input) {
1343 if (isHtml() && input != null) {
1344 return StringUtils.unhtml(input);
1345 }
1346
1347 return input;
1348 }
1349
1350 /**
1351 * Return a {@link BasicSupport} implementation supporting the given
1352 * resource if possible.
1353 *
1354 * @param url
1355 * the story resource
1356 *
1357 * @return an implementation that supports it, or NULL
1358 */
1359 public static BasicSupport getSupport(URL url) {
1360 if (url == null) {
1361 return null;
1362 }
1363
1364 // TEXT and INFO_TEXT always support files (not URLs though)
1365 for (SupportType type : SupportType.values()) {
1366 if (type != SupportType.TEXT && type != SupportType.INFO_TEXT) {
1367 BasicSupport support = getSupport(type);
1368 if (support != null && support.supports(url)) {
1369 return support;
1370 }
1371 }
1372 }
1373
1374 for (SupportType type : new SupportType[] { SupportType.INFO_TEXT,
1375 SupportType.TEXT }) {
1376 BasicSupport support = getSupport(type);
1377 if (support != null && support.supports(url)) {
1378 return support;
1379 }
1380 }
1381
1382 return null;
1383 }
1384
1385 /**
1386 * Return a {@link BasicSupport} implementation supporting the given type.
1387 *
1388 * @param type
1389 * the type
1390 *
1391 * @return an implementation that supports it, or NULL
1392 */
1393 public static BasicSupport getSupport(SupportType type) {
1394 switch (type) {
1395 case EPUB:
1396 return new Epub().setType(type);
1397 case INFO_TEXT:
1398 return new InfoText().setType(type);
1399 case FIMFICTION:
1400 try {
1401 // Can fail if no client key or NO in options
1402 return new FimfictionApi().setType(type);
1403 } catch (IOException e) {
1404 return new Fimfiction().setType(type);
1405 }
1406 case FANFICTION:
1407 return new Fanfiction().setType(type);
1408 case TEXT:
1409 return new Text().setType(type);
1410 case MANGAFOX:
1411 return new MangaFox().setType(type);
1412 case E621:
1413 return new E621().setType(type);
1414 case YIFFSTAR:
1415 return new YiffStar().setType(type);
1416 case E_HENTAI:
1417 return new EHentai().setType(type);
1418 case CBZ:
1419 return new Cbz().setType(type);
1420 case HTML:
1421 return new Html().setType(type);
1422 }
1423
1424 return null;
1425 }
1426
1427 /**
1428 * Reset the given {@link InputStream} and return it.
1429 *
1430 * @param in
1431 * the {@link InputStream} to reset
1432 *
1433 * @return the same {@link InputStream} after reset
1434 */
1435 static protected InputStream reset(InputStream in) {
1436 try {
1437 if (in != null) {
1438 in.reset();
1439 }
1440 } catch (IOException e) {
1441 }
1442
1443 return in;
1444 }
1445
1446 /**
1447 * Return the first line from the given input which correspond to the given
1448 * selectors.
1449 *
1450 * @param in
1451 * the input
1452 * @param needle
1453 * a string that must be found inside the target line (also
1454 * supports "^" at start to say "only if it starts with" the
1455 * needle)
1456 * @param relativeLine
1457 * the line to return based upon the target line position (-1 =
1458 * the line before, 0 = the target line...)
1459 *
1460 * @return the line
1461 */
1462 static protected String getLine(InputStream in, String needle,
1463 int relativeLine) {
1464 return getLine(in, needle, relativeLine, true);
1465 }
1466
1467 /**
1468 * Return a line from the given input which correspond to the given
1469 * selectors.
1470 *
1471 * @param in
1472 * the input
1473 * @param needle
1474 * a string that must be found inside the target line (also
1475 * supports "^" at start to say "only if it starts with" the
1476 * needle)
1477 * @param relativeLine
1478 * the line to return based upon the target line position (-1 =
1479 * the line before, 0 = the target line...)
1480 * @param first
1481 * takes the first result (as opposed to the last one, which will
1482 * also always spend the input)
1483 *
1484 * @return the line
1485 */
1486 static protected String getLine(InputStream in, String needle,
1487 int relativeLine, boolean first) {
1488 String rep = null;
1489
1490 reset(in);
1491
1492 List<String> lines = new ArrayList<String>();
1493 @SuppressWarnings("resource")
1494 Scanner scan = new Scanner(in, "UTF-8");
1495 int index = -1;
1496 scan.useDelimiter("\\n");
1497 while (scan.hasNext()) {
1498 lines.add(scan.next());
1499
1500 if (index == -1) {
1501 if (needle.startsWith("^")) {
1502 if (lines.get(lines.size() - 1).startsWith(
1503 needle.substring(1))) {
1504 index = lines.size() - 1;
1505 }
1506
1507 } else {
1508 if (lines.get(lines.size() - 1).contains(needle)) {
1509 index = lines.size() - 1;
1510 }
1511 }
1512 }
1513
1514 if (index >= 0 && index + relativeLine < lines.size()) {
1515 rep = lines.get(index + relativeLine);
1516 if (first) {
1517 break;
1518 }
1519 }
1520 }
1521
1522 return rep;
1523 }
1524
1525 /**
1526 * Return the text between the key and the endKey (and optional subKey can
1527 * be passed, in this case we will look for the key first, then take the
1528 * text between the subKey and the endKey).
1529 * <p>
1530 * Will only match the first line with the given key if more than one are
1531 * possible. Which also means that if the subKey or endKey is not found on
1532 * that line, NULL will be returned.
1533 *
1534 * @param in
1535 * the input
1536 * @param key
1537 * the key to match (also supports "^" at start to say
1538 * "only if it starts with" the key)
1539 * @param subKey
1540 * the sub key or NULL if none
1541 * @param endKey
1542 * the end key or NULL for "up to the end"
1543 * @return the text or NULL if not found
1544 */
1545 static protected String getKeyLine(InputStream in, String key,
1546 String subKey, String endKey) {
1547 return getKeyText(getLine(in, key, 0), key, subKey, endKey);
1548 }
1549
1550 /**
1551 * Return the text between the key and the endKey (and optional subKey can
1552 * be passed, in this case we will look for the key first, then take the
1553 * text between the subKey and the endKey).
1554 *
1555 * @param in
1556 * the input
1557 * @param key
1558 * the key to match (also supports "^" at start to say
1559 * "only if it starts with" the key)
1560 * @param subKey
1561 * the sub key or NULL if none
1562 * @param endKey
1563 * the end key or NULL for "up to the end"
1564 * @return the text or NULL if not found
1565 */
1566 static protected String getKeyText(String in, String key, String subKey,
1567 String endKey) {
1568 String result = null;
1569
1570 String line = in;
1571 if (line != null && line.contains(key)) {
1572 line = line.substring(line.indexOf(key) + key.length());
1573 if (subKey == null || subKey.isEmpty() || line.contains(subKey)) {
1574 if (subKey != null) {
1575 line = line.substring(line.indexOf(subKey)
1576 + subKey.length());
1577 }
1578 if (endKey == null || line.contains(endKey)) {
1579 if (endKey != null) {
1580 line = line.substring(0, line.indexOf(endKey));
1581 result = line;
1582 }
1583 }
1584 }
1585 }
1586
1587 return result;
1588 }
1589
1590 /**
1591 * Return the text between the key and the endKey (optional subKeys can be
1592 * passed, in this case we will look for the subKeys first, then take the
1593 * text between the key and the endKey).
1594 *
1595 * @param in
1596 * the input
1597 * @param key
1598 * the key to match
1599 * @param endKey
1600 * the end key or NULL for "up to the end"
1601 * @param afters
1602 * the sub-keys to find before checking for key/endKey
1603 *
1604 * @return the text or NULL if not found
1605 */
1606 static protected String getKeyTextAfter(String in, String key,
1607 String endKey, String... afters) {
1608
1609 if (in != null && !in.isEmpty()) {
1610 int pos = indexOfAfter(in, 0, afters);
1611 if (pos < 0) {
1612 return null;
1613 }
1614
1615 in = in.substring(pos);
1616 }
1617
1618 return getKeyText(in, key, null, endKey);
1619 }
1620
1621 /**
1622 * Return the first index after all the given "afters" have been found in
1623 * the {@link String}, or -1 if it was not possible.
1624 *
1625 * @param in
1626 * the input
1627 * @param startAt
1628 * start at this position in the string
1629 * @param afters
1630 * the sub-keys to find before checking for key/endKey
1631 *
1632 * @return the text or NULL if not found
1633 */
1634 static protected int indexOfAfter(String in, int startAt, String... afters) {
1635 int pos = -1;
1636 if (in != null && !in.isEmpty()) {
1637 pos = startAt;
1638 if (afters != null) {
1639 for (int i = 0; pos >= 0 && i < afters.length; i++) {
1640 String subKey = afters[i];
1641 if (!subKey.isEmpty()) {
1642 pos = in.indexOf(subKey, pos);
1643 if (pos >= 0) {
1644 pos += subKey.length();
1645 }
1646 }
1647 }
1648 }
1649 }
1650
1651 return pos;
1652 }
1653}