src/be/nikiroo/fanfix/supported/Text.java

   1 package be.nikiroo.fanfix.supported;
   2
   3 import java.io.File;
   4 import java.io.FileInputStream;
   5 import java.io.IOException;
   6 import java.io.InputStream;
   7 import java.net.URISyntaxException;
   8 import java.net.URL;
   9 import java.util.AbstractMap;
  10 import java.util.ArrayList;
  11 import java.util.List;
  12 import java.util.Map.Entry;
  13 import java.util.Scanner;
  14
  15 import org.jsoup.nodes.Document;
  16
  17 import be.nikiroo.fanfix.Instance;
  18 import be.nikiroo.fanfix.bundles.Config;
  19 import be.nikiroo.fanfix.data.MetaData;
  20 import be.nikiroo.utils.Image;
  21 import be.nikiroo.utils.ImageUtils;
  22 import be.nikiroo.utils.streams.MarkableFileInputStream;
  23 import be.nikiroo.utils.Progress;
  24
  25 /**
  26  * Support class for local stories encoded in textual format, with a few rules:
  27  * <ul>
  28  * <li>The title must be on the first line</li>
  29  * <li>The author (preceded by nothing, "by " or "©") must be on the second
  30  * line, possibly with the publication date in parenthesis (i.e., "
  31  * <tt>By Unknown (3rd October 1998)</tt>")</li>
  32  * <li>Chapters must be declared with "<tt>Chapter x</tt>" or "
  33  * <tt>Chapter x: NAME OF THE CHAPTER</tt>", where "<tt>x</tt>" is the chapter
  34  * number</li>
  35  * <li>A description of the story must be given as chapter number 0</li>
  36  * <li>A cover may be present, with the same filename but a PNG, JPEG or JPG
  37  * extension</li>
  38  * </ul>
  39  *
  40  * @author niki
  41  */
  42 class Text extends BasicSupport {
  43         private File sourceFile;
  44         private InputStream in;
  45
  46         protected File getSourceFile() {
  47                 return sourceFile;
  48         }
  49
  50         protected InputStream getInput() {
  51                 if (in != null) {
  52                         try {
  53                                 in.reset();
  54                         } catch (IOException e) {
  55                                 Instance.getTraceHandler().error(
  56                                                 new IOException("Cannot reset the Text stream", e));
  57                         }
  58
  59                         return in;
  60                 }
  61
  62                 return null;
  63         }
  64
  65         @Override
  66         protected boolean isHtml() {
  67                 return false;
  68         }
  69
  70         @Override
  71         protected Document loadDocument(URL source) throws IOException {
  72                 try {
  73                         sourceFile = new File(source.toURI());
  74                         in = new MarkableFileInputStream(sourceFile);
  75                 } catch (URISyntaxException e) {
  76                         throw new IOException("Cannot load the text document: " + source);
  77                 }
  78
  79                 return null;
  80         }
  81
  82         @Override
  83         protected MetaData getMeta() throws IOException {
  84                 MetaData meta = new MetaData();
  85
  86                 meta.setTitle(getTitle());
  87                 meta.setAuthor(getAuthor());
  88                 meta.setDate(getDate());
  89                 meta.setTags(new ArrayList<String>());
  90                 meta.setSource(getType().getSourceName());
  91                 meta.setUrl(getSourceFile().toURI().toURL().toString());
  92                 meta.setPublisher("");
  93                 meta.setUuid(getSourceFile().toString());
  94                 meta.setLuid("");
  95                 meta.setLang(getLang()); // default is EN
  96                 meta.setSubject(getSourceFile().getParentFile().getName());
  97                 meta.setType(getType().toString());
  98                 meta.setImageDocument(false);
  99                 meta.setCover(getCover(getSourceFile()));
 100
 101                 return meta;
 102         }
 103
 104         private String getLang() {
 105                 @SuppressWarnings("resource")
 106                 Scanner scan = new Scanner(getInput(), "UTF-8");
 107                 scan.useDelimiter("\\n");
 108                 scan.next(); // Title
 109                 scan.next(); // Author (Date)
 110                 String chapter0 = scan.next(); // empty or Chapter 0
 111                 while (chapter0.isEmpty()) {
 112                         chapter0 = scan.next();
 113                 }
 114
 115                 String lang = detectChapter(chapter0, 0);
 116                 if (lang == null) {
 117                         // No description??
 118                         lang = detectChapter(chapter0, 1);
 119                 }
 120
 121                 if (lang == null) {
 122                         lang = "en";
 123                 } else {
 124                         lang = lang.toLowerCase();
 125                 }
 126
 127                 return lang;
 128         }
 129
 130         private String getTitle() {
 131                 @SuppressWarnings("resource")
 132                 Scanner scan = new Scanner(getInput(), "UTF-8");
 133                 scan.useDelimiter("\\n");
 134                 return scan.next();
 135         }
 136
 137         private String getAuthor() {
 138                 @SuppressWarnings("resource")
 139                 Scanner scan = new Scanner(getInput(), "UTF-8");
 140                 scan.useDelimiter("\\n");
 141                 scan.next();
 142                 String authorDate = scan.next();
 143
 144                 String author = authorDate;
 145                 int pos = authorDate.indexOf('(');
 146                 if (pos >= 0) {
 147                         author = authorDate.substring(0, pos);
 148                 }
 149
 150                 return BasicSupportHelper.fixAuthor(author);
 151         }
 152
 153         private String getDate() {
 154                 @SuppressWarnings("resource")
 155                 Scanner scan = new Scanner(getInput(), "UTF-8");
 156                 scan.useDelimiter("\\n");
 157                 scan.next();
 158                 String authorDate = scan.next();
 159
 160                 String date = "";
 161                 int pos = authorDate.indexOf('(');
 162                 if (pos >= 0) {
 163                         date = authorDate.substring(pos + 1).trim();
 164                         pos = date.lastIndexOf(')');
 165                         if (pos >= 0) {
 166                                 date = date.substring(0, pos).trim();
 167                         }
 168                 }
 169
 170                 return date;
 171         }
 172
 173         @Override
 174         protected String getDesc() throws IOException {
 175                 return getChapterContent(null, 0, null);
 176         }
 177
 178         private Image getCover(File sourceFile) {
 179                 String path = sourceFile.getName();
 180
 181                 for (String ext : new String[] { ".txt", ".text", ".story" }) {
 182                         if (path.endsWith(ext)) {
 183                                 path = path.substring(0, path.length() - ext.length());
 184                         }
 185                 }
 186
 187                 Image cover = BasicSupportImages.getImage(this,
 188                                 sourceFile.getParentFile(), path);
 189                 if (cover != null) {
 190                         try {
 191                                 File tmp = Instance.getTempFiles().createTempFile(
 192                                                 "test_cover_image");
 193                                 ImageUtils.getInstance().saveAsImage(cover, tmp, "png");
 194                                 tmp.delete();
 195                         } catch (IOException e) {
 196                                 cover = null;
 197                         }
 198                 }
 199
 200                 return cover;
 201         }
 202
 203         @Override
 204         protected List<Entry<String, URL>> getChapters(Progress pg)
 205                         throws IOException {
 206                 List<Entry<String, URL>> chaps = new ArrayList<Entry<String, URL>>();
 207                 @SuppressWarnings("resource")
 208                 Scanner scan = new Scanner(getInput(), "UTF-8");
 209                 scan.useDelimiter("\\n");
 210                 boolean prevLineEmpty = false;
 211                 while (scan.hasNext()) {
 212                         String line = scan.next();
 213                         if (prevLineEmpty && detectChapter(line, chaps.size() + 1) != null) {
 214                                 String chapName = Integer.toString(chaps.size() + 1);
 215                                 int pos = line.indexOf(':');
 216                                 if (pos >= 0 && pos + 1 < line.length()) {
 217                                         chapName = line.substring(pos + 1).trim();
 218                                 }
 219
 220                                 chaps.add(new AbstractMap.SimpleEntry<String, URL>(//
 221                                                 chapName, //
 222                                                 getSourceFile().toURI().toURL()));
 223                         }
 224
 225                         prevLineEmpty = line.trim().isEmpty();
 226                 }
 227
 228                 return chaps;
 229         }
 230
 231         @Override
 232         protected String getChapterContent(URL source, int number, Progress pg)
 233                         throws IOException {
 234                 StringBuilder builder = new StringBuilder();
 235                 @SuppressWarnings("resource")
 236                 Scanner scan = new Scanner(getInput(), "UTF-8");
 237                 scan.useDelimiter("\\n");
 238                 boolean inChap = false;
 239                 while (scan.hasNext()) {
 240                         String line = scan.next();
 241                         if (detectChapter(line, number) != null) {
 242                                 inChap = true;
 243                         } else if (inChap && detectChapter(line, number + 1) != null) {
 244                                 break;
 245                         } else if (inChap) {
 246                                 builder.append(line);
 247                                 builder.append("\n");
 248                         }
 249                 }
 250
 251                 return builder.toString();
 252         }
 253
 254         @Override
 255         protected void close() {
 256                 InputStream in = getInput();
 257                 if (in != null) {
 258                         try {
 259                                 in.close();
 260                         } catch (IOException e) {
 261                                 Instance.getTraceHandler().error(
 262                                                 new IOException(
 263                                                                 "Cannot close the text source file input", e));
 264                         }
 265                 }
 266
 267                 super.close();
 268         }
 269
 270         @Override
 271         protected boolean supports(URL url) {
 272                 return supports(url, false);
 273         }
 274
 275         /**
 276          * Check if we supports this {@link URL}, that is, if the info file can be
 277          * found OR not found.
 278          *
 279          * @param url
 280          *            the {@link URL} to check
 281          * @param info
 282          *            TRUE to require the info file, FALSE to forbid the info file
 283          *
 284          * @return TRUE if it is supported
 285          */
 286         protected boolean supports(URL url, boolean info) {
 287                 boolean infoPresent = false;
 288                 if ("file".equals(url.getProtocol())) {
 289                         File file;
 290                         try {
 291                                 file = new File(url.toURI());
 292                                 file = assureNoTxt(file);
 293                                 file = new File(file.getPath() + ".info");
 294                         } catch (URISyntaxException e) {
 295                                 Instance.getTraceHandler().error(e);
 296                                 file = null;
 297                         }
 298
 299                         infoPresent = (file != null && file.exists());
 300                 }
 301
 302                 return infoPresent == info;
 303         }
 304
 305         /**
 306          * Remove the ".txt" extension if it is present.
 307          *
 308          * @param file
 309          *            the file to process
 310          *
 311          * @return the same file or a copy of it without the ".txt" extension if it
 312          *         was present
 313          */
 314         protected File assureNoTxt(File file) {
 315                 if (file.getName().endsWith(".txt")) {
 316                         file = new File(file.getPath().substring(0,
 317                                         file.getPath().length() - 4));
 318                 }
 319
 320                 return file;
 321         }
 322
 323         /**
 324          * Check if the given line looks like the given starting chapter in a
 325          * supported language, and return the language if it does (or NULL if not).
 326          *
 327          * @param line
 328          *            the line to check
 329          *
 330          * @return the language or NULL
 331          */
 332         static private String detectChapter(String line, int number) {
 333                 line = line.toUpperCase();
 334                 for (String lang : Instance.getConfig().getString(Config.CHAPTER)
 335                                 .split(",")) {
 336                         String chapter = Instance.getConfig().getStringX(Config.CHAPTER,
 337                                         lang);
 338                         if (chapter != null && !chapter.isEmpty()) {
 339                                 chapter = chapter.toUpperCase() + " ";
 340                                 if (line.startsWith(chapter)) {
 341                                         // We want "[CHAPTER] [number]: [name]", with ": [name]"
 342                                         // optional
 343                                         String test = line.substring(chapter.length()).trim();
 344                                         if (test.startsWith(Integer.toString(number))) {
 345                                                 test = test
 346                                                                 .substring(Integer.toString(number).length())
 347                                                                 .trim();
 348                                                 if (test.isEmpty() || test.startsWith(":")) {
 349                                                         return lang;
 350                                                 }
 351                                         }
 352                                 }
 353                         }
 354                 }
 355
 356                 return null;
 357         }
 358 }