import be.nikiroo.fanfix.data.Paragraph;
import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
import be.nikiroo.fanfix.data.Story;
-import be.nikiroo.utils.IOUtils;
+import be.nikiroo.utils.ImageUtils;
import be.nikiroo.utils.Progress;
import be.nikiroo.utils.StringUtils;
E621,
/** Furry website with stories */
YIFFSTAR,
+ /** Comics and images groups, mostly but not only NSFW */
+ E_HENTAI,
/** CBZ files */
CBZ,
/** HTML files */
}
/**
- * Call {@link SupportType#valueOf(String.toUpperCase())}.
+ * Call {@link SupportType#valueOf(String)} after conversion to upper
+ * case.
*
* @param typeName
* the possible type name
}
/**
- * Call {@link SupportType#valueOf(String.toUpperCase())} but return
- * NULL for NULL instead of raising exception.
+ * Call {@link SupportType#valueOf(String)} after conversion to upper
+ * case but return NULL for NULL instead of raising exception.
*
* @param typeName
* the possible type name
}
/**
- * Call {@link SupportType#valueOf(String.toUpperCase())} but return
- * NULL in case of error instead of raising an exception.
+ * Call {@link SupportType#valueOf(String)} after conversion to upper
+ * case but return NULL in case of error instead of raising an
+ * exception.
*
* @param typeName
* the possible type name
private URL currentReferer; // with only one 'r', as in 'HTTP'...
// quote chars
- private char openQuote = Instance.getTrans().getChar(
+ private char openQuote = Instance.getTrans().getCharacter(
StringId.OPEN_SINGLE_QUOTE);
- private char closeQuote = Instance.getTrans().getChar(
+ private char closeQuote = Instance.getTrans().getCharacter(
StringId.CLOSE_SINGLE_QUOTE);
- private char openDoubleQuote = Instance.getTrans().getChar(
+ private char openDoubleQuote = Instance.getTrans().getCharacter(
StringId.OPEN_DOUBLE_QUOTE);
- private char closeDoubleQuote = Instance.getTrans().getChar(
+ private char closeDoubleQuote = Instance.getTrans().getCharacter(
StringId.CLOSE_DOUBLE_QUOTE);
/**
*/
protected abstract boolean isHtml();
+ /**
+ * Return the {@link MetaData} of this story.
+ *
+ * @param source
+ * the source of the story
+ * @param in
+ * the input (the main resource)
+ *
+ * @return the associated {@link MetaData}
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
protected abstract MetaData getMeta(URL source, InputStream in)
throws IOException;
* the source of the story
* @param in
* the input (the main resource)
+ * @param pg
+ * the optional progress reporter
*
* @return the chapters
*
* in case of I/O error
*/
protected abstract List<Entry<String, URL>> getChapters(URL source,
- InputStream in) throws IOException;
+ InputStream in, Progress pg) throws IOException;
/**
* Return the content of the chapter (possibly HTML encoded, if
* the input (the main resource)
* @param number
* the chapter number
+ * @param pg
+ * the optional progress reporter
*
* @return the content
*
* in case of I/O error
*/
protected abstract String getChapterContent(URL source, InputStream in,
- int number) throws IOException;
+ int number, Progress pg) throws IOException;
/**
* Log into the support (can be a no-op depending upon the support).
* @throws IOException
* in case of I/O error
*/
+ @SuppressWarnings("unused")
public void login() throws IOException {
-
}
/**
* it.
*
* @return the cookies
- *
- * @throws IOException
- * in case of I/O error
*/
- public Map<String, String> getCookies() throws IOException {
+ public Map<String, String> getCookies() {
return new HashMap<String, String>();
}
+ /**
+ * OAuth authorisation (aka, "bearer XXXXXXX").
+ *
+ * @return the OAuth string
+ */
+ public String getOAuth() {
+ return null;
+ }
+
/**
* Return the canonical form of the main {@link URL}.
*
* @throws IOException
* in case of I/O error
*/
+ @SuppressWarnings("unused")
public URL getCanonicalUrl(URL source) throws IOException {
return source;
}
* in case of I/O error
*/
public Story processMeta(URL url) throws IOException {
- return processMeta(url, true, false);
+ return processMeta(url, true, false, null);
}
/**
*
* @param url
* the story resource
- *
* @param close
* close "this" and "in" when done
+ * @param getDesc
+ * retrieve the description of the story, or not
+ * @param pg
+ * the optional progress reporter
*
* @return the {@link Story}
*
* @throws IOException
* in case of I/O error
*/
- protected Story processMeta(URL url, boolean close, boolean getDesc)
- throws IOException {
+ protected Story processMeta(URL url, boolean close, boolean getDesc,
+ Progress pg) throws IOException {
+ if (pg == null) {
+ pg = new Progress();
+ } else {
+ pg.setMinMax(0, 100);
+ }
+
login();
+ pg.setProgress(10);
url = getCanonicalUrl(url);
setCurrentReferer(url);
- in = openInput(url);
- if (in == null) {
- return null;
- }
-
+ in = openInput(url); // NULL allowed here
try {
preprocess(url, getInput());
+ pg.setProgress(30);
Story story = new Story();
MetaData meta = getMeta(url, getInput());
}
story.setMeta(meta);
- if (meta != null && meta.getCover() == null) {
+ pg.setProgress(50);
+
+ if (meta.getCover() == null) {
meta.setCover(getDefaultCover(meta.getSubject()));
}
+ pg.setProgress(60);
+
if (getDesc) {
String descChapterName = Instance.getTrans().getString(
StringId.DESCRIPTION);
story.getMeta().setResume(
makeChapter(url, 0, descChapterName,
- getDesc(url, getInput())));
+ getDesc(url, getInput()), null));
}
+ pg.setProgress(100);
return story;
} finally {
if (close) {
url = getCanonicalUrl(url);
pg.setProgress(1);
try {
- Story story = processMeta(url, false, true);
- pg.setProgress(10);
+ Progress pgMeta = new Progress();
+ pg.addProgress(pgMeta, 10);
+ Story story = processMeta(url, false, true, pgMeta);
+ if (!pgMeta.isDone()) {
+ pgMeta.setProgress(pgMeta.getMax()); // 10%
+ }
+
if (story == null) {
- pg.setProgress(100);
+ pg.setProgress(90);
return null;
}
setCurrentReferer(url);
+ Progress pgGetChapters = new Progress();
+ pg.addProgress(pgGetChapters, 10);
story.setChapters(new ArrayList<Chapter>());
+ List<Entry<String, URL>> chapters = getChapters(url, getInput(),
+ pgGetChapters);
+ if (!pgGetChapters.isDone()) {
+ pgGetChapters.setProgress(pgGetChapters.getMax()); // 20%
+ }
- List<Entry<String, URL>> chapters = getChapters(url, getInput());
- pg.setProgress(20);
-
- int i = 1;
if (chapters != null) {
- Progress pgChaps = new Progress(0, chapters.size());
+ Progress pgChaps = new Progress("Extracting chapters", 0,
+ chapters.size() * 300);
pg.addProgress(pgChaps, 80);
long words = 0;
+ int i = 1;
for (Entry<String, URL> chap : chapters) {
- setCurrentReferer(chap.getValue());
- InputStream chapIn = Instance.getCache().open(
- chap.getValue(), this, true);
+ pgChaps.setName("Extracting chapter " + i);
+ InputStream chapIn = null;
+ if (chap.getValue() != null) {
+ setCurrentReferer(chap.getValue());
+ chapIn = Instance.getCache().open(chap.getValue(),
+ this, true);
+ }
+ pgChaps.setProgress(i * 100);
try {
+ Progress pgGetChapterContent = new Progress();
+ Progress pgMakeChapter = new Progress();
+ pgChaps.addProgress(pgGetChapterContent, 100);
+ pgChaps.addProgress(pgMakeChapter, 100);
+
+ String content = getChapterContent(url, chapIn, i,
+ pgGetChapterContent);
+ if (!pgGetChapterContent.isDone()) {
+ pgGetChapterContent.setProgress(pgGetChapterContent
+ .getMax());
+ }
+
Chapter cc = makeChapter(url, i, chap.getKey(),
- getChapterContent(url, chapIn, i));
+ content, pgMakeChapter);
+ if (!pgMakeChapter.isDone()) {
+ pgMakeChapter.setProgress(pgMakeChapter.getMax());
+ }
+
words += cc.getWords();
story.getChapters().add(cc);
if (story.getMeta() != null) {
story.getMeta().setWords(words);
}
} finally {
- chapIn.close();
+ if (chapIn != null) {
+ chapIn.close();
+ }
}
- pgChaps.setProgress(i++);
+ i++;
}
+
+ pgChaps.setName("Extracting chapters");
} else {
- pg.setProgress(100);
+ pg.setProgress(80);
}
return story;
* @throws IOException
* on I/O error
*/
+ @SuppressWarnings("unused")
protected void preprocess(URL source, InputStream in) throws IOException {
}
* @throws IOException
* on I/O error
*/
+ @SuppressWarnings("unused")
protected void close() throws IOException {
}
* Create a {@link Chapter} object from the given information, formatting
* the content as it should be.
*
+ * @param source
+ * the source of the story
* @param number
* the chapter number
* @param name
* the chapter name
* @param content
* the chapter content
+ * @param pg
+ * the optional progress reporter
*
* @return the {@link Chapter}
*
* in case of I/O error
*/
protected Chapter makeChapter(URL source, int number, String name,
- String content) throws IOException {
+ String content, Progress pg) throws IOException {
// Chapter name: process it correctly, then remove the possible
- // redundant "Chapter x: " in front of it
+ // redundant "Chapter x: " in front of it, or "-" (as in
+ // "Chapter 5: - Fun!" after the ": " was automatically added)
String chapterName = processPara(name).getContent().trim();
for (String lang : Instance.getConfig().getString(Config.CHAPTER)
.split(",")) {
Integer.toString(number).length()).trim();
}
- if (chapterName.startsWith(":")) {
+ while (chapterName.startsWith(":") || chapterName.startsWith("-")) {
chapterName = chapterName.substring(1).trim();
}
//
Chapter chap = new Chapter(number, chapterName);
if (content != null) {
- List<Paragraph> paras = makeParagraphs(source, content);
+ List<Paragraph> paras = makeParagraphs(source, content, pg);
long words = 0;
for (Paragraph para : paras) {
words += para.getWords();
* the source URL of the story
* @param content
* the textual content
+ * @param pg
+ * the optional progress reporter
*
* @return the {@link Paragraph}s
*
* @throws IOException
* in case of I/O error
*/
- protected List<Paragraph> makeParagraphs(URL source, String content)
- throws IOException {
+ protected List<Paragraph> makeParagraphs(URL source, String content,
+ Progress pg) throws IOException {
+ if (pg == null) {
+ pg = new Progress();
+ }
+
if (isHtml()) {
// Special <HR> processing:
content = content.replaceAll("(<hr [^>]*>)|(<hr/>)|(<hr>)",
if (content != null && !content.trim().isEmpty()) {
if (isHtml()) {
- for (String line : content.split("(<p>|</p>|<br>|<br/>)")) {
+ String[] tab = content.split("(<p>|</p>|<br>|<br/>)");
+ pg.setMinMax(0, tab.length);
+ int i = 1;
+ for (String line : tab) {
+ if (line.startsWith("[") && line.endsWith("]")) {
+ pg.setName("Extracting image " + i);
+ }
paras.add(makeParagraph(source, line.trim()));
+ pg.setProgress(i++);
}
+ pg.setName(null);
} else {
+ List<String> lines = new ArrayList<String>();
BufferedReader buff = null;
try {
buff = new BufferedReader(
content.getBytes("UTF-8")), "UTF-8"));
for (String line = buff.readLine(); line != null; line = buff
.readLine()) {
- paras.add(makeParagraph(source, line.trim()));
+ lines.add(line.trim());
}
} finally {
if (buff != null) {
buff.close();
}
}
+
+ pg.setMinMax(0, lines.size());
+ int i = 0;
+ for (String line : lines) {
+ if (line.startsWith("[") && line.endsWith("]")) {
+ pg.setName("Extracting image " + i);
+ }
+ paras.add(makeParagraph(source, line));
+ pg.setProgress(i++);
+ }
+ pg.setName(null);
}
// Check quotes for "bad" format
if (image != null) {
return new Paragraph(image);
- } else {
- return processPara(line);
}
+
+ return processPara(line);
}
/**
static String[] getImageExt(boolean emptyAllowed) {
if (emptyAllowed) {
return new String[] { "", ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
- } else {
- return new String[] { ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
}
+
+ return new String[] { ".png", ".jpg", ".jpeg", ".gif", ".bmp" };
}
/**
InputStream in = null;
try {
in = Instance.getCache().open(url, getSupport(url), true);
- return IOUtils.toImage(in);
+ return ImageUtils.fromStream(in);
} catch (IOException e) {
} finally {
if (in != null) {
if (line != null) {
// try for files
- String path = null;
if (source != null) {
- path = new File(source.getFile()).getParent();
try {
- String basePath = new File(new File(path), line.trim())
- .getAbsolutePath();
+
+ String relPath = null;
+ String absPath = null;
+ try {
+ String path = new File(source.getFile()).getParent();
+ relPath = new File(new File(path), line.trim())
+ .getAbsolutePath();
+ } catch (Exception e) {
+ // Cannot be converted to path (one possibility to take
+ // into account: absolute path on Windows)
+ }
+ try {
+ absPath = new File(line.trim()).getAbsolutePath();
+ } catch (Exception e) {
+ // Cannot be converted to path (at all)
+ }
+
for (String ext : getImageExt(true)) {
- if (new File(basePath + ext).exists()) {
- url = new File(basePath + ext).toURI().toURL();
+ if (absPath != null && new File(absPath + ext).exists()) {
+ url = new File(absPath + ext).toURI().toURL();
+ } else if (relPath != null
+ && new File(relPath + ext).exists()) {
+ url = new File(relPath + ext).toURI().toURL();
}
}
} catch (Exception e) {
- // Nothing to do here
+ // Should not happen since we control the correct arguments
}
}
/**
* Open the input file that will be used through the support.
+ * <p>
+ * Can return NULL, in which case you are supposed to work without an
+ * {@link InputStream}.
*
* @param source
* the source {@link URL}
return Instance.getCache().open(source, this, false);
}
- /**
- * Reset the given {@link InputStream} and return it.
- *
- * @param in
- * the {@link InputStream} to reset
- *
- * @return the same {@link InputStream} after reset
- */
- protected InputStream reset(InputStream in) {
- try {
- in.reset();
- } catch (IOException e) {
- }
- return in;
- }
-
/**
* Reset then return {@link BasicSupport#in}.
*
if (prev == car) {
builder.append(closeDoubleQuote);
continue;
- } else {
- builder.append(closeQuote);
}
+
+ builder.append(closeQuote);
}
}
case INFO_TEXT:
return new InfoText().setType(type);
case FIMFICTION:
- return new Fimfiction().setType(type);
+ try {
+ // Can fail if no client key or NO in options
+ return new FimfictionApi().setType(type);
+ } catch (IOException e) {
+ return new Fimfiction().setType(type);
+ }
case FANFICTION:
return new Fanfiction().setType(type);
case TEXT:
return new E621().setType(type);
case YIFFSTAR:
return new YiffStar().setType(type);
+ case E_HENTAI:
+ return new EHentai().setType(type);
case CBZ:
return new Cbz().setType(type);
case HTML:
return null;
}
+ /**
+ * Reset the given {@link InputStream} and return it.
+ *
+ * @param in
+ * the {@link InputStream} to reset
+ *
+ * @return the same {@link InputStream} after reset
+ */
+ static protected InputStream reset(InputStream in) {
+ try {
+ if (in != null) {
+ in.reset();
+ }
+ } catch (IOException e) {
+ }
+
+ return in;
+ }
+
/**
* Return the first line from the given input which correspond to the given
* selectors.
*
* @return the line
*/
- static String getLine(InputStream in, String needle, int relativeLine) {
+ static protected String getLine(InputStream in, String needle,
+ int relativeLine) {
return getLine(in, needle, relativeLine, true);
}
*
* @return the line
*/
- static String getLine(InputStream in, String needle, int relativeLine,
- boolean first) {
+ static protected String getLine(InputStream in, String needle,
+ int relativeLine, boolean first) {
String rep = null;
- try {
- in.reset();
- } catch (IOException e) {
- Instance.syserr(e);
- }
+ reset(in);
List<String> lines = new ArrayList<String>();
@SuppressWarnings("resource")
return rep;
}
+
+ /**
+ * Return the text between the key and the endKey (and optional subKey can
+ * be passed, in this case we will look for the key first, then take the
+ * text between the subKey and the endKey).
+ * <p>
+ * Will only match the first line with the given key if more than one are
+ * possible. Which also means that if the subKey or endKey is not found on
+ * that line, NULL will be returned.
+ *
+ * @param in
+ * the input
+ * @param key
+ * the key to match (also supports "^" at start to say
+ * "only if it starts with" the key)
+ * @param subKey
+ * the sub key or NULL if none
+ * @param endKey
+ * the end key or NULL for "up to the end"
+ * @return the text or NULL if not found
+ */
+ static protected String getKeyLine(InputStream in, String key,
+ String subKey, String endKey) {
+ return getKeyText(getLine(in, key, 0), key, subKey, endKey);
+ }
+
+ /**
+ * Return the text between the key and the endKey (and optional subKey can
+ * be passed, in this case we will look for the key first, then take the
+ * text between the subKey and the endKey).
+ *
+ * @param in
+ * the input
+ * @param key
+ * the key to match (also supports "^" at start to say
+ * "only if it starts with" the key)
+ * @param subKey
+ * the sub key or NULL if none
+ * @param endKey
+ * the end key or NULL for "up to the end"
+ * @return the text or NULL if not found
+ */
+ static protected String getKeyText(String in, String key, String subKey,
+ String endKey) {
+ String result = null;
+
+ String line = in;
+ if (line != null && line.contains(key)) {
+ line = line.substring(line.indexOf(key) + key.length());
+ if (subKey == null || subKey.isEmpty() || line.contains(subKey)) {
+ if (subKey != null) {
+ line = line.substring(line.indexOf(subKey)
+ + subKey.length());
+ }
+ if (endKey == null || line.contains(endKey)) {
+ if (endKey != null) {
+ line = line.substring(0, line.indexOf(endKey));
+ result = line;
+ }
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Return the text between the key and the endKey (optional subKeys can be
+ * passed, in this case we will look for the subKeys first, then take the
+ * text between the key and the endKey).
+ *
+ * @param in
+ * the input
+ * @param key
+ * the key to match
+ * @param endKey
+ * the end key or NULL for "up to the end"
+ * @param afters
+ * the sub-keys to find before checking for key/endKey
+ *
+ * @return the text or NULL if not found
+ */
+ static protected String getKeyTextAfter(String in, String key,
+ String endKey, String... afters) {
+
+ if (in != null && !in.isEmpty()) {
+ int pos = indexOfAfter(in, 0, afters);
+ if (pos < 0) {
+ return null;
+ }
+
+ in = in.substring(pos);
+ }
+
+ return getKeyText(in, key, null, endKey);
+ }
+
+ /**
+ * Return the first index after all the given "afters" have been found in
+ * the {@link String}, or -1 if it was not possible.
+ *
+ * @param in
+ * the input
+ * @param startAt
+ * start at this position in the string
+ * @param afters
+ * the sub-keys to find before checking for key/endKey
+ *
+ * @return the text or NULL if not found
+ */
+ static protected int indexOfAfter(String in, int startAt, String... afters) {
+ int pos = -1;
+ if (in != null && !in.isEmpty()) {
+ pos = startAt;
+ if (afters != null) {
+ for (int i = 0; pos >= 0 && i < afters.length; i++) {
+ String subKey = afters[i];
+ if (!subKey.isEmpty()) {
+ pos = in.indexOf(subKey, pos);
+ if (pos >= 0) {
+ pos += subKey.length();
+ }
+ }
+ }
+ }
+ }
+
+ return pos;
+ }
}