package be.nikiroo.fanfix.supported;
-import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import be.nikiroo.fanfix.data.Paragraph;
import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
import be.nikiroo.fanfix.data.Story;
-import be.nikiroo.utils.ImageUtils;
+import be.nikiroo.utils.Image;
import be.nikiroo.utils.Progress;
import be.nikiroo.utils.StringUtils;
* @param in
* the input (the main resource)
*
- * @return the associated {@link MetaData}
+ * @return the associated {@link MetaData}, never NULL
*
* @throws IOException
* in case of I/O error
* @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;
}
* @param pg
* the optional progress reporter
*
- * @return the {@link Story}
+ * @return the {@link Story}, never NULL
*
* @throws IOException
* in case of I/O error
setCurrentReferer(url);
- in = openInput(url);
- if (in == null) {
- return null;
- }
-
+ in = openInput(url); // NULL allowed here
try {
preprocess(url, getInput());
pg.setProgress(30);
pg.setProgress(50);
- if (meta != null && meta.getCover() == null) {
+ if (meta.getCover() == null) {
meta.setCover(getDefaultCover(meta.getSubject()));
}
try {
close();
} catch (IOException e) {
- Instance.syserr(e);
+ Instance.getTraceHandler().error(e);
}
if (in != null) {
* @param pg
* the optional progress reporter
*
- * @return the {@link Story}
+ * @return the {@link Story}, never NULL
*
* @throws IOException
* in case of I/O error
pgMeta.setProgress(pgMeta.getMax()); // 10%
}
- if (story == null) {
- pg.setProgress(90);
- return null;
- }
-
pg.setName("Retrieving " + story.getMeta().getTitle());
setCurrentReferer(url);
int i = 1;
for (Entry<String, URL> chap : chapters) {
pgChaps.setName("Extracting chapter " + i);
- setCurrentReferer(chap.getValue());
- InputStream chapIn = Instance.getCache().open(
- chap.getValue(), this, true);
+ 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();
words += cc.getWords();
story.getChapters().add(cc);
- if (story.getMeta() != null) {
- story.getMeta().setWords(words);
- }
+ story.getMeta().setWords(words);
} finally {
- chapIn.close();
+ if (chapIn != null) {
+ chapIn.close();
+ }
}
i++;
try {
close();
} catch (IOException e) {
- Instance.syserr(e);
+ Instance.getTraceHandler().error(e);
}
if (in != null) {
* @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 {
}
* @return the {@link Paragraph}
*/
private Paragraph makeParagraph(URL source, String line) {
- URL image = null;
+ Image image = null;
if (line.startsWith("[") && line.endsWith("]")) {
- image = getImageUrl(this, source,
- line.substring(1, line.length() - 1).trim());
+ image = getImage(this, source, line.substring(1, line.length() - 1)
+ .trim());
}
if (image != null) {
return new Paragraph(image);
- } else {
- return processPara(line);
}
+
+ return processPara(line);
}
/**
*
* @return the cover if any, or NULL
*/
- static BufferedImage getDefaultCover(String subject) {
+ static Image getDefaultCover(String subject) {
if (subject != null && !subject.isEmpty()
&& Instance.getCoverDir() != null) {
try {
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" };
}
/**
* @return the image if found, or NULL
*
*/
- static BufferedImage getImage(BasicSupport support, URL source, String line) {
+ static Image getImage(BasicSupport support, URL source, String line) {
URL url = getImageUrl(support, source, line);
if (url != null) {
+ if ("file".equals(url.getProtocol())) {
+ if (new File(url.getPath()).isDirectory()) {
+ return null;
+ }
+ }
InputStream in = null;
try {
in = Instance.getCache().open(url, getSupport(url), true);
- return ImageUtils.fromStream(in);
+ return new Image(in);
} catch (IOException e) {
} finally {
if (in != null) {
}
for (String ext : getImageExt(true)) {
- 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();
+ File absFile = new File(absPath + ext);
+ File relFile = new File(relPath + ext);
+ if (absPath != null && absFile.exists()
+ && absFile.isFile()) {
+ url = absFile.toURI().toURL();
+ } else if (relPath != null && relFile.exists()
+ && relFile.isFile()) {
+ url = relFile.toURI().toURL();
}
}
} catch (Exception e) {
// try for URLs
try {
for (String ext : getImageExt(true)) {
- if (Instance.getCache().check(new URL(line + ext))) {
+ if (Instance.getCache()
+ .check(new URL(line + ext), true)) {
url = new URL(line + ext);
break;
}
/**
* 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 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")
* the end key or NULL for "up to the end"
* @return the text or NULL if not found
*/
- static String getKeyLine(InputStream in, String key, String subKey,
+ 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 = getLine(in, key, 0);
+ 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)) {
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;
+ }
}
git://git.nikiroo.be / fanfix.git / blobdiff