Merge branch 'subtree'
[fanfix.git] / src / be / nikiroo / fanfix / library / LocalLibrary.java
index 9ebff72c2151d7d6f6e7e0f6cf86fafc42911aed..6720972682939785226de86a201ef2c4c4c7d68f 100644 (file)
@@ -13,6 +13,7 @@ import java.util.Map;
 
 import be.nikiroo.fanfix.Instance;
 import be.nikiroo.fanfix.bundles.Config;
+import be.nikiroo.fanfix.bundles.ConfigBundle;
 import be.nikiroo.fanfix.data.MetaData;
 import be.nikiroo.fanfix.data.Story;
 import be.nikiroo.fanfix.output.BasicOutput;
@@ -22,6 +23,7 @@ import be.nikiroo.fanfix.supported.InfoReader;
 import be.nikiroo.utils.IOUtils;
 import be.nikiroo.utils.Image;
 import be.nikiroo.utils.Progress;
+import be.nikiroo.utils.StringUtils;
 
 /**
  * This {@link BasicLibrary} will store the stories locally on disk.
@@ -30,8 +32,10 @@ import be.nikiroo.utils.Progress;
  */
 public class LocalLibrary extends BasicLibrary {
        private int lastId;
+       private Object lock = new Object();
        private Map<MetaData, File[]> stories; // Files: [ infoFile, TargetFile ]
        private Map<String, Image> sourceCovers;
+       private Map<String, Image> authorCovers;
 
        private File baseDir;
        private OutputType text;
@@ -42,11 +46,15 @@ public class LocalLibrary extends BasicLibrary {
         * 
         * @param baseDir
         *            the directory where to find the {@link Story} objects
+        * @param config
+        *            the configuration used to know which kind of default
+        *            {@link OutputType} to use for images and non-images stories
         */
-       public LocalLibrary(File baseDir) {
-               this(baseDir, Instance.getConfig().getString(
-                               Config.NON_IMAGES_DOCUMENT_TYPE), Instance.getConfig()
-                               .getString(Config.IMAGES_DOCUMENT_TYPE), false);
+       public LocalLibrary(File baseDir, ConfigBundle config) {
+               this(baseDir, //
+                               config.getString(Config.FILE_FORMAT_NON_IMAGES_DOCUMENT_TYPE),
+                               config.getString(Config.FILE_FORMAT_IMAGES_DOCUMENT_TYPE),
+                               false);
        }
 
        /**
@@ -64,8 +72,9 @@ public class LocalLibrary extends BasicLibrary {
         */
        public LocalLibrary(File baseDir, String text, String image,
                        boolean defaultIsHtml) {
-               this(baseDir, OutputType.valueOfAllOkUC(text,
-                               defaultIsHtml ? OutputType.HTML : OutputType.INFO_TEXT),
+               this(baseDir,
+                               OutputType.valueOfAllOkUC(text,
+                                               defaultIsHtml ? OutputType.HTML : OutputType.INFO_TEXT),
                                OutputType.valueOfAllOkUC(image,
                                                defaultIsHtml ? OutputType.HTML : OutputType.CBZ));
        }
@@ -98,29 +107,31 @@ public class LocalLibrary extends BasicLibrary {
        }
 
        @Override
-       public File getFile(String luid, Progress pg) {
-               Instance.getTraceHandler().trace(
+       public File getFile(String luid, Progress pg) throws IOException {
+               Instance.getInstance().getTraceHandler().trace(
                                this.getClass().getSimpleName() + ": get file for " + luid);
 
                File file = null;
                String mess = "no file found for ";
 
                MetaData meta = getInfo(luid);
-               File[] files = getStories(pg).get(meta);
-               if (files != null) {
-                       mess = "file retrieved for ";
-                       file = files[1];
+               if (meta != null) {
+                       File[] files = getStories(pg).get(meta);
+                       if (files != null) {
+                               mess = "file retrieved for ";
+                               file = files[1];
+                       }
                }
 
-               Instance.getTraceHandler().trace(
-                               this.getClass().getSimpleName() + ": " + mess + luid + " ("
-                                               + meta.getTitle() + ")");
+               Instance.getInstance().getTraceHandler()
+                               .trace(this.getClass().getSimpleName() + ": " + mess + luid
+                                               + " (" + meta.getTitle() + ")");
 
                return file;
        }
 
        @Override
-       public Image getCover(String luid) {
+       public Image getCover(String luid) throws IOException {
                MetaData meta = getInfo(luid);
                if (meta != null) {
                        if (meta.getCover() != null) {
@@ -135,7 +146,7 @@ public class LocalLibrary extends BasicLibrary {
                                        meta = InfoReader.readMeta(infoFile, true);
                                        return meta.getCover();
                                } catch (IOException e) {
-                                       Instance.getTraceHandler().error(e);
+                                       Instance.getInstance().getTraceHandler().error(e);
                                }
                        }
                }
@@ -144,20 +155,25 @@ public class LocalLibrary extends BasicLibrary {
        }
 
        @Override
-       protected synchronized void updateInfo(MetaData meta) {
+       protected void updateInfo(MetaData meta) {
                invalidateInfo();
        }
 
        @Override
        protected void invalidateInfo(String luid) {
-               stories = null;
-               sourceCovers = null;
+               synchronized (lock) {
+                       stories = null;
+                       sourceCovers = null;
+               }
        }
 
        @Override
-       protected synchronized int getNextId() {
+       protected int getNextId() {
                getStories(null); // make sure lastId is set
-               return ++lastId;
+
+               synchronized (lock) {
+                       return ++lastId;
+               }
        }
 
        @Override
@@ -187,7 +203,7 @@ public class LocalLibrary extends BasicLibrary {
                        throws IOException {
                File newDir = getExpectedDir(meta.getSource());
                if (!newDir.exists()) {
-                       newDir.mkdir();
+                       newDir.mkdirs();
                }
 
                List<File> relatedFiles = getRelatedFiles(meta.getLuid());
@@ -197,13 +213,13 @@ public class LocalLibrary extends BasicLibrary {
                        // Maybe also adding some rollback cleanup if possible
                        if (relatedFile.getName().endsWith(".info")) {
                                try {
-                                       String name = relatedFile.getName().replaceFirst(
-                                                       "\\.info$", "");
+                                       String name = relatedFile.getName().replaceFirst("\\.info$",
+                                                       "");
                                        relatedFile.delete();
                                        InfoCover.writeInfo(newDir, name, meta);
                                        relatedFile.getParentFile().delete();
                                } catch (IOException e) {
-                                       Instance.getTraceHandler().error(e);
+                                       Instance.getInstance().getTraceHandler().error(e);
                                }
                        } else {
                                relatedFile.renameTo(new File(newDir, relatedFile.getName()));
@@ -211,21 +227,25 @@ public class LocalLibrary extends BasicLibrary {
                        }
                }
 
-               invalidateInfo();
+               updateInfo(meta);
        }
 
        @Override
-       public synchronized Image getCustomSourceCover(String source) {
-               if (sourceCovers == null) {
-                       sourceCovers = new HashMap<String, Image>();
+       public Image getCustomSourceCover(String source) {
+               synchronized (lock) {
+                       if (sourceCovers == null) {
+                               sourceCovers = new HashMap<String, Image>();
+                       }
                }
 
-               Image img = sourceCovers.get(source);
-               if (img != null) {
-                       return img;
+               synchronized (lock) {
+                       Image img = sourceCovers.get(source);
+                       if (img != null) {
+                               return img;
+                       }
                }
 
-               File coverDir = new File(baseDir, source);
+               File coverDir = getExpectedDir(source);
                if (coverDir.isDirectory()) {
                        File cover = new File(coverDir, ".cover.png");
                        if (cover.exists()) {
@@ -233,48 +253,128 @@ public class LocalLibrary extends BasicLibrary {
                                try {
                                        in = new FileInputStream(cover);
                                        try {
-                                               sourceCovers.put(source, new Image(in));
+                                               synchronized (lock) {
+                                                       sourceCovers.put(source, new Image(in));
+                                               }
                                        } finally {
                                                in.close();
                                        }
                                } catch (FileNotFoundException e) {
                                        e.printStackTrace();
                                } catch (IOException e) {
-                                       Instance.getTraceHandler().error(
-                                                       new IOException(
+                                       Instance.getInstance().getTraceHandler()
+                                                       .error(new IOException(
                                                                        "Cannot load the existing custom source cover: "
-                                                                                       + cover, e));
+                                                                                       + cover,
+                                                                       e));
+                               }
+                       }
+               }
+
+               synchronized (lock) {
+                       return sourceCovers.get(source);
+               }
+       }
+
+       @Override
+       public Image getCustomAuthorCover(String author) {
+               synchronized (lock) {
+                       if (authorCovers == null) {
+                               authorCovers = new HashMap<String, Image>();
+                       }
+               }
+
+               synchronized (lock) {
+                       Image img = authorCovers.get(author);
+                       if (img != null) {
+                               return img;
+                       }
+               }
+
+               File cover = getAuthorCoverFile(author);
+               if (cover.exists()) {
+                       InputStream in;
+                       try {
+                               in = new FileInputStream(cover);
+                               try {
+                                       synchronized (lock) {
+                                               authorCovers.put(author, new Image(in));
+                                       }
+                               } finally {
+                                       in.close();
                                }
+                       } catch (FileNotFoundException e) {
+                               e.printStackTrace();
+                       } catch (IOException e) {
+                               Instance.getInstance().getTraceHandler()
+                                               .error(new IOException(
+                                                               "Cannot load the existing custom author cover: "
+                                                                               + cover,
+                                                               e));
                        }
                }
 
-               return sourceCovers.get(source);
+               synchronized (lock) {
+                       return authorCovers.get(author);
+               }
        }
 
        @Override
-       public void setSourceCover(String source, String luid) {
+       public void setSourceCover(String source, String luid) throws IOException {
                setSourceCover(source, getCover(luid));
        }
 
+       @Override
+       public void setAuthorCover(String author, String luid) throws IOException {
+               setAuthorCover(author, getCover(luid));
+       }
+
        /**
-        * Fix the source cover to the given story cover.
+        * Set the source cover to the given story cover.
         * 
         * @param source
         *            the source to change
         * @param coverImage
         *            the cover image
         */
-       synchronized void setSourceCover(String source, Image coverImage) {
+       void setSourceCover(String source, Image coverImage) {
                File dir = getExpectedDir(source);
                dir.mkdirs();
                File cover = new File(dir, ".cover");
                try {
-                       Instance.getCache().saveAsImage(coverImage, cover, true);
-                       if (sourceCovers != null) {
-                               sourceCovers.put(source, coverImage);
+                       Instance.getInstance().getCache().saveAsImage(coverImage, cover,
+                                       true);
+                       synchronized (lock) {
+                               if (sourceCovers != null) {
+                                       sourceCovers.put(source, coverImage);
+                               }
                        }
                } catch (IOException e) {
-                       Instance.getTraceHandler().error(e);
+                       Instance.getInstance().getTraceHandler().error(e);
+               }
+       }
+
+       /**
+        * Set the author cover to the given story cover.
+        * 
+        * @param author
+        *            the author to change
+        * @param coverImage
+        *            the cover image
+        */
+       void setAuthorCover(String author, Image coverImage) {
+               File cover = getAuthorCoverFile(author);
+               cover.getParentFile().mkdirs();
+               try {
+                       Instance.getInstance().getCache().saveAsImage(coverImage, cover,
+                                       true);
+                       synchronized (lock) {
+                               if (authorCovers != null) {
+                                       authorCovers.put(author, coverImage);
+                               }
+                       }
+               } catch (IOException e) {
+                       Instance.getInstance().getTraceHandler().error(e);
                }
        }
 
@@ -295,19 +395,21 @@ public class LocalLibrary extends BasicLibrary {
                        if (meta != null && meta.getType().equals(expectedType)) {
                                File from = otherLocalLibrary.getExpectedDir(meta.getSource());
                                File to = this.getExpectedDir(meta.getSource());
-                               List<File> sources = otherLocalLibrary.getRelatedFiles(luid);
-                               if (!sources.isEmpty()) {
-                                       pg.setMinMax(0, sources.size());
+                               List<File> relatedFiles = otherLocalLibrary
+                                               .getRelatedFiles(luid);
+                               if (!relatedFiles.isEmpty()) {
+                                       pg.setMinMax(0, relatedFiles.size());
                                }
 
-                               for (File source : sources) {
-                                       File target = new File(source.getAbsolutePath().replace(
-                                                       from.getAbsolutePath(), to.getAbsolutePath()));
-                                       if (!source.equals(target)) {
+                               for (File relatedFile : relatedFiles) {
+                                       File target = new File(relatedFile.getAbsolutePath()
+                                                       .replace(from.getAbsolutePath(),
+                                                                       to.getAbsolutePath()));
+                                       if (!relatedFile.equals(target)) {
                                                target.getParentFile().mkdirs();
                                                InputStream in = null;
                                                try {
-                                                       in = new FileInputStream(source);
+                                                       in = new FileInputStream(relatedFile);
                                                        IOUtils.write(in, target);
                                                } catch (IOException e) {
                                                        if (in != null) {
@@ -350,6 +452,22 @@ public class LocalLibrary extends BasicLibrary {
                return text;
        }
 
+       /**
+        * Return the default {@link OutputType} for this kind of {@link Story}.
+        * 
+        * @param imageDocument
+        *            TRUE for images document, FALSE for text documents
+        * 
+        * @return the type
+        */
+       public String getOutputType(boolean imageDocument) {
+               if (imageDocument) {
+                       return image.toString();
+               }
+
+               return text.toString();
+       }
+
        /**
         * Get the target {@link File} related to the given <tt>.info</tt>
         * {@link File} and {@link MetaData}.
@@ -385,8 +503,11 @@ public class LocalLibrary extends BasicLibrary {
                        title = "";
                }
                title = title.replaceAll("[^a-zA-Z0-9._+-]", "_");
-               return new File(getExpectedDir(key.getSource()), key.getLuid() + "_"
-                               + title);
+               if (title.length() > 40) {
+                       title = title.substring(0, 40);
+               }
+               return new File(getExpectedDir(key.getSource()),
+                               key.getLuid() + "_" + title);
        }
 
        /**
@@ -399,10 +520,45 @@ public class LocalLibrary extends BasicLibrary {
         * @return the target directory
         */
        private File getExpectedDir(String source) {
-               String sanitizedSource = source.replaceAll("[^a-zA-Z0-9._+-]", "_");
+               String sanitizedSource = source.replaceAll("[^a-zA-Z0-9._+/-]", "_");
+
+               while (sanitizedSource.startsWith("/")
+                               || sanitizedSource.startsWith("_")) {
+                       if (sanitizedSource.length() > 1) {
+                               sanitizedSource = sanitizedSource.substring(1);
+                       } else {
+                               sanitizedSource = "";
+                       }
+               }
+
+               sanitizedSource = sanitizedSource.replace("/", File.separator);
+
+               if (sanitizedSource.isEmpty()) {
+                       sanitizedSource = "_EMPTY";
+               }
+
                return new File(baseDir, sanitizedSource);
        }
 
+       /**
+        * Return the full path to the file to use for the custom cover of this
+        * author.
+        * <p>
+        * One or more of the parent directories <b>MAY</b> not exist.
+        * 
+        * @param author
+        *            the author
+        * 
+        * @return the custom cover file
+        */
+       private File getAuthorCoverFile(String author) {
+               File aDir = new File(baseDir, "_AUTHORS");
+               String hash = StringUtils.getMd5Hash(author);
+               String ext = Instance.getInstance().getConfig()
+                               .getString(Config.FILE_FORMAT_IMAGE_FORMAT_COVER);
+               return new File(aDir, hash + "." + ext.toLowerCase());
+       }
+
        /**
         * Return the list of files/directories on disk for this {@link Story}.
         * <p>
@@ -444,14 +600,13 @@ public class LocalLibrary extends BasicLibrary {
                        }
                }
 
-               String coverExt = "."
-                               + Instance.getConfig().getString(Config.IMAGE_FORMAT_COVER)
-                                               .toLowerCase();
+               String coverExt = "." + Instance.getInstance().getConfig()
+                               .getString(Config.FILE_FORMAT_IMAGE_FORMAT_COVER).toLowerCase();
                File coverFile = new File(path + coverExt);
                if (!coverFile.exists()) {
-                       coverFile = new File(path.substring(0,
-                                       path.length() - fileExt.length())
-                                       + coverExt);
+                       coverFile = new File(
+                                       path.substring(0, path.length() - fileExt.length())
+                                                       + coverExt);
                }
 
                if (coverFile.exists()) {
@@ -474,82 +629,126 @@ public class LocalLibrary extends BasicLibrary {
         * @return the list of stories (for each item, the first {@link File} is the
         *         info file, the second file is the target {@link File})
         */
-       private synchronized Map<MetaData, File[]> getStories(Progress pg) {
+       private Map<MetaData, File[]> getStories(Progress pg) {
                if (pg == null) {
                        pg = new Progress();
                } else {
                        pg.setMinMax(0, 100);
                }
 
+               Map<MetaData, File[]> stories = this.stories;
                if (stories == null) {
-                       stories = new HashMap<MetaData, File[]>();
+                       stories = getStoriesDo(pg);
+                       synchronized (lock) {
+                               if (this.stories == null)
+                                       this.stories = stories;
+                               else
+                                       stories = this.stories;
+                       }
+               }
 
-                       lastId = 0;
+               pg.done();
+               return stories;
 
-                       File[] dirs = baseDir.listFiles(new FileFilter() {
-                               @Override
-                               public boolean accept(File file) {
-                                       return file != null && file.isDirectory();
-                               }
-                       });
-
-                       if (dirs != null) {
-                               Progress pgDirs = new Progress(0, 100 * dirs.length);
-                               pg.addProgress(pgDirs, 100);
-
-                               for (File dir : dirs) {
-                                       File[] infoFiles = dir.listFiles(new FileFilter() {
-                                               @Override
-                                               public boolean accept(File file) {
-                                                       return file != null
-                                                                       && file.getPath().toLowerCase()
-                                                                                       .endsWith(".info");
-                                               }
-                                       });
+       }
 
-                                       Progress pgFiles = new Progress(0, infoFiles.length);
-                                       pgDirs.addProgress(pgFiles, 100);
-                                       pgDirs.setName("Loading from: " + dir.getName());
+       /**
+        * Actually do the work of {@link LocalLibrary#getStories(Progress)} (i.e.,
+        * do not retrieve the cache).
+        * 
+        * @param pg
+        *            the optional {@link Progress}
+        * 
+        * @return the list of stories (for each item, the first {@link File} is the
+        *         info file, the second file is the target {@link File})
+        */
+       private synchronized Map<MetaData, File[]> getStoriesDo(Progress pg) {
+               if (pg == null) {
+                       pg = new Progress();
+               } else {
+                       pg.setMinMax(0, 100);
+               }
 
-                                       for (File infoFile : infoFiles) {
-                                               pgFiles.setName(infoFile.getName());
-                                               try {
-                                                       MetaData meta = InfoReader
-                                                                       .readMeta(infoFile, false);
-                                                       try {
-                                                               int id = Integer.parseInt(meta.getLuid());
-                                                               if (id > lastId) {
-                                                                       lastId = id;
-                                                               }
+               Map<MetaData, File[]> stories = new HashMap<MetaData, File[]>();
 
-                                                               stories.put(meta, new File[] { infoFile,
-                                                                               getTargetFile(meta, infoFile) });
-                                                       } catch (Exception e) {
-                                                               // not normal!!
-                                                               throw new IOException(
-                                                                               "Cannot understand the LUID of "
-                                                                                               + infoFile + ": "
-                                                                                               + meta.getLuid(), e);
-                                                       }
-                                               } catch (IOException e) {
-                                                       // We should not have not-supported files in the
-                                                       // library
-                                                       Instance.getTraceHandler().error(
-                                                                       new IOException(
-                                                                                       "Cannot load file from library: "
-                                                                                                       + infoFile, e));
-                                               }
-                                               pgFiles.add(1);
-                                       }
+               File[] dirs = baseDir.listFiles(new FileFilter() {
+                       @Override
+                       public boolean accept(File file) {
+                               return file != null && file.isDirectory();
+                       }
+               });
 
-                                       pgFiles.setName(null);
-                               }
+               if (dirs != null) {
+                       Progress pgDirs = new Progress(0, 100 * dirs.length);
+                       pg.addProgress(pgDirs, 100);
+
+                       for (File dir : dirs) {
+                               Progress pgFiles = new Progress();
+                               pgDirs.addProgress(pgFiles, 100);
+                               pgDirs.setName("Loading from: " + dir.getName());
 
-                               pgDirs.setName("Loading directories");
+                               addToStories(stories, pgFiles, dir);
+
+                               pgFiles.setName(null);
                        }
+
+                       pgDirs.setName("Loading directories");
                }
 
                pg.done();
+
                return stories;
        }
+
+       private void addToStories(Map<MetaData, File[]> stories, Progress pgFiles,
+                       File dir) {
+               File[] infoFilesAndSubdirs = dir.listFiles(new FileFilter() {
+                       @Override
+                       public boolean accept(File file) {
+                               boolean info = file != null && file.isFile()
+                                               && file.getPath().toLowerCase().endsWith(".info");
+                               boolean dir = file != null && file.isDirectory();
+                               boolean isExpandedHtml = new File(file, "index.html").isFile();
+                               return info || (dir && !isExpandedHtml);
+                       }
+               });
+
+               if (pgFiles != null) {
+                       pgFiles.setMinMax(0, infoFilesAndSubdirs.length);
+               }
+
+               for (File infoFileOrSubdir : infoFilesAndSubdirs) {
+                       if (infoFileOrSubdir.isDirectory()) {
+                               addToStories(stories, null, infoFileOrSubdir);
+                       } else {
+                               try {
+                                       MetaData meta = InfoReader.readMeta(infoFileOrSubdir,
+                                                       false);
+                                       try {
+                                               int id = Integer.parseInt(meta.getLuid());
+                                               if (id > lastId) {
+                                                       lastId = id;
+                                               }
+
+                                               stories.put(meta, new File[] { infoFileOrSubdir,
+                                                               getTargetFile(meta, infoFileOrSubdir) });
+                                       } catch (Exception e) {
+                                               // not normal!!
+                                               throw new IOException("Cannot understand the LUID of "
+                                                               + infoFileOrSubdir + ": " + meta.getLuid(), e);
+                                       }
+                               } catch (IOException e) {
+                                       // We should not have not-supported files in the
+                                       // library
+                                       Instance.getInstance().getTraceHandler().error(
+                                                       new IOException("Cannot load file from library: "
+                                                                       + infoFileOrSubdir, e));
+                               }
+                       }
+
+                       if (pgFiles != null) {
+                               pgFiles.add(1);
+                       }
+               }
+       }
 }