[fanfix.git] / src / be / nikiroo / fanfix / supported / MangaFox.java

package be.nikiroo.fanfix.supported;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map.Entry;
import java.util.Scanner;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.utils.StringUtils;

class MangaFox extends BasicSupport {
	@Override
	protected boolean isHtml() {
		return true;
	}

	@Override
	public String getSourceName() {
		return "MangaFox.met";
	}

	@Override
	protected String getSubject(URL source, InputStream in) {
		return "manga";
	}

	@Override
	public boolean isImageDocument(URL source, InputStream in)
			throws IOException {
		return true;
	}

	@Override
	protected List<String> getTags(URL source, InputStream in) {
		List<String> tags = new ArrayList<String>();

		String line = getLine(in, "/genres/", 0);
		if (line != null) {
			line = StringUtils.unhtml(line);
			String[] tab = line.split(",");
			if (tab != null) {
				for (String tag : tab) {
					tags.add(tag.trim());
				}
			}
		}

		return tags;
	}

	@Override
	protected String getTitle(URL source, InputStream in) {
		String line = getLine(in, " property=\"og:title\"", 0);
		if (line != null) {
			int pos = -1;
			for (int i = 0; i < 3; i++) {
				pos = line.indexOf('"', pos + 1);
			}

			if (pos >= 0) {
				line = line.substring(pos + 1);
				pos = line.indexOf('"');
				if (pos >= 0) {
					return line.substring(0, pos);
				}
			}
		}

		return null;
	}

	@Override
	protected String getAuthor(URL source, InputStream in) {
		List<String> authors = new ArrayList<String>();

		String line = getLine(in, "/author/", 0, false);
		if (line != null) {
			for (String ln : StringUtils.unhtml(line).split(",")) {
				if (ln != null && !ln.trim().isEmpty()
						&& !authors.contains(ln.trim())) {
					authors.add(ln.trim());
				}
			}
		}

		try {
			in.reset();
		} catch (IOException e) {
			Instance.syserr(e);
		}

		line = getLine(in, "/artist/", 0, false);
		if (line != null) {
			for (String ln : StringUtils.unhtml(line).split(",")) {
				if (ln != null && !ln.trim().isEmpty()
						&& !authors.contains(ln.trim())) {
					authors.add(ln.trim());
				}
			}
		}

		if (authors.isEmpty()) {
			return null;
		} else {
			StringBuilder builder = new StringBuilder();
			for (String author : authors) {
				if (builder.length() > 0) {
					builder.append(", ");
				}

				builder.append(author);
			}

			return builder.toString();
		}
	}

	@Override
	protected String getDate(URL source, InputStream in) {
		String line = getLine(in, "/released/", 0);
		if (line != null) {
			line = StringUtils.unhtml(line);
			return line.trim();
		}

		return null;
	}

	@Override
	protected String getDesc(URL source, InputStream in) {
		String line = getLine(in, " property=\"og:description\"", 0);
		if (line != null) {
			int pos = -1;
			for (int i = 0; i < 3; i++) {
				pos = line.indexOf('"', pos + 1);
			}

			if (pos >= 0) {
				line = line.substring(pos + 1);
				pos = line.indexOf('"');
				if (pos >= 0) {
					return line.substring(0, pos);
				}
			}
		}

		return null;
	}

	@Override
	protected URL getCover(URL url, InputStream in) {
		String line = getLine(in, " property=\"og:image\"", 0);
		String cover = null;
		if (line != null) {
			int pos = -1;
			for (int i = 0; i < 3; i++) {
				pos = line.indexOf('"', pos + 1);
			}

			if (pos >= 0) {
				line = line.substring(pos + 1);
				pos = line.indexOf('"');
				if (pos >= 0) {
					cover = line.substring(0, pos);
				}
			}
		}

		if (cover != null) {
			try {
				return new URL(cover);
			} catch (MalformedURLException e) {
				Instance.syserr(e);
			}
		}

		return null;
	}

	@Override
	protected List<Entry<String, URL>> getChapters(URL source, InputStream in) {
		List<Entry<String, URL>> urls = new ArrayList<Entry<String, URL>>();

		String volumeAt = "<h3 class=\"volume\">";
		String linkAt = "href=\"http://mangafox.me/";
		String endAt = "<script type=\"text/javascript\">";

		boolean started = false;

		@SuppressWarnings("resource")
		Scanner scan = new Scanner(in, "UTF-8");
		scan.useDelimiter("\\n");
		while (scan.hasNext()) {
			String line = scan.next();

			if (started && line.contains(endAt)) {
				break;
			} else if (!started && line.contains(volumeAt)) {
				started = true;
			}

			if (started && line.contains(linkAt)) {
				// Chapter content url
				String url = null;
				int pos = line.indexOf("href=\"");
				if (pos >= 0) {
					line = line.substring(pos + "href=\"".length());
					pos = line.indexOf('\"');
					if (pos >= 0) {
						url = line.substring(0, pos);
					}
				}

				// Chapter name
				String name = null;
				if (scan.hasNext()) {
					name = StringUtils.unhtml(scan.next()).trim();
					// Remove the "new" tag if present
					if (name.endsWith("new")) {
						name = name.substring(0, name.length() - 3).trim();
					}
				}

				// to help with the retry and the originalUrl
				refresh(url);

				try {
					final String key = name;
					final URL value = new URL(url);
					urls.add(new Entry<String, URL>() {
						public URL setValue(URL value) {
							return null;
						}

						public String getKey() {
							return key;
						}

						public URL getValue() {
							return value;
						}
					});
				} catch (MalformedURLException e) {
					Instance.syserr(e);
				}
			}
		}

		// the chapters are in reversed order
		Collections.reverse(urls);

		return urls;
	}

	@Override
	protected String getChapterContent(URL source, InputStream in, int number) {
		StringBuilder builder = new StringBuilder();
		String base = getCurrentReferer().toString();
		int pos = base.lastIndexOf('/');
		base = base.substring(0, pos + 1); // including the '/' at the end

		boolean close = false;
		while (in != null) {
			String linkNextLine = getLine(in, "return enlarge()", 0);
			try {
				in.reset();
			} catch (IOException e) {
				Instance.syserr(e);
			}

			String linkImageLine = getLine(in, "return enlarge()", 1);
			String linkNext = null;
			String linkImage = null;
			pos = linkNextLine.indexOf("href=\"");
			if (pos >= 0) {
				linkNextLine = linkNextLine.substring(pos + "href=\"".length());
				pos = linkNextLine.indexOf('\"');
				if (pos >= 0) {
					linkNext = linkNextLine.substring(0, pos);
				}
			}
			pos = linkImageLine.indexOf("src=\"");
			if (pos >= 0) {
				linkImageLine = linkImageLine
						.substring(pos + "src=\"".length());
				pos = linkImageLine.indexOf('\"');
				if (pos >= 0) {
					linkImage = linkImageLine.substring(0, pos);
				}
			}

			if (linkImage != null) {
				builder.append("[");
				// to help with the retry and the originalUrl, part 1
				builder.append(withoutQuery(linkImage));
				builder.append("]\n");
			}

			// to help with the retry and the originalUrl, part 2
			refresh(linkImage);

			if (close) {
				try {
					in.close();
				} catch (IOException e) {
					Instance.syserr(e);
				}
			}

			in = null;
			if (linkNext != null && !"javascript:void(0);".equals(linkNext)) {
				URL url;
				try {
					url = new URL(base + linkNext);
					in = openEx(base + linkNext);
					setCurrentReferer(url);
				} catch (IOException e) {
					Instance.syserr(new IOException(
							"Cannot get the next manga page which is: "
									+ linkNext, e));
				}
			}

			close = true;
		}

		setCurrentReferer(source);
		return builder.toString();
	}

	@Override
	protected boolean supports(URL url) {
		return "mangafox.me".equals(url.getHost())
				|| "www.mangafox.me".equals(url.getHost());
	}

	/**
	 * Refresh the {@link URL} by calling {@link MangaFox#openEx(String)}.
	 * 
	 * @param url
	 *            the URL to refresh
	 * 
	 * @return TRUE if it was refreshed
	 */
	private boolean refresh(String url) {
		try {
			openEx(url).close();
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/**
	 * Open the URL through the cache, but: retry a second time after 100ms if
	 * it fails, remove the query part of the {@link URL} before saving it to
	 * the cache (so it can be recalled later).
	 * 
	 * @param url
	 *            the {@link URL}
	 * 
	 * @return the resource
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	private InputStream openEx(String url) throws IOException {
		try {
			return Instance.getCache().open(new URL(url), this, true,
					withoutQuery(url));
		} catch (Exception e) {
			// second chance
			try {
				Thread.sleep(100);
			} catch (InterruptedException ee) {
			}

			return Instance.getCache().open(new URL(url), this, true,
					withoutQuery(url));
		}
	}

	/**
	 * Return the same input {@link URL} but without the query part.
	 * 
	 * @param url
	 *            the inpiut {@link URL} as a {@link String}
	 * 
	 * @return the input {@link URL} without query
	 */
	private URL withoutQuery(String url) {
		URL o = null;
		try {
			// Remove the query from o (originalUrl), so it can be cached
			// correctly
			o = new URL(url);
			o = new URL(o.getProtocol() + "://" + o.getHost() + o.getPath());

			return o;
		} catch (MalformedURLException e) {
			return null;
		}
	}
}
Commit	Line	Data
08fe2e33 NR	1	package be.nikiroo.fanfix.supported;
	2
	3	import java.io.IOException;
	4	import java.io.InputStream;
	5	import java.net.MalformedURLException;
	6	import java.net.URL;
	7	import java.util.ArrayList;
	8	import java.util.Collections;
	9	import java.util.List;
	10	import java.util.Map.Entry;
	11	import java.util.Scanner;
	12
	13	import be.nikiroo.fanfix.Instance;
	14	import be.nikiroo.utils.StringUtils;
	15
	16	class MangaFox extends BasicSupport {
	17	@Override
	18	protected boolean isHtml() {
	19	return true;
	20	}
	21
	22	@Override
	23	public String getSourceName() {
	24	return "MangaFox.met";
	25	}
	26
	27	@Override
	28	protected String getSubject(URL source, InputStream in) {
	29	return "manga";
	30	}
	31
	32	@Override
	33	public boolean isImageDocument(URL source, InputStream in)
	34	throws IOException {
	35	return true;
	36	}
	37
	38	@Override
	39	protected List<String> getTags(URL source, InputStream in) {
	40	List<String> tags = new ArrayList<String>();
	41
	42	String line = getLine(in, "/genres/", 0);
	43	if (line != null) {
	44	line = StringUtils.unhtml(line);
	45	String[] tab = line.split(",");
	46	if (tab != null) {
	47	for (String tag : tab) {
	48	tags.add(tag.trim());
	49	}
	50	}
	51	}
	52
	53	return tags;
	54	}
	55
	56	@Override
	57	protected String getTitle(URL source, InputStream in) {
	58	String line = getLine(in, " property=\"og:title\"", 0);
	59	if (line != null) {
	60	int pos = -1;
	61	for (int i = 0; i < 3; i++) {
	62	pos = line.indexOf('"', pos + 1);
	63	}
	64
65	if (pos >= 0) {
66	line = line.substring(pos + 1);
67	pos = line.indexOf('"');
68	if (pos >= 0) {
69	return line.substring(0, pos);
70	}
71	}
72	}
73
74	return null;
75	}
76
77	@Override
78	protected String getAuthor(URL source, InputStream in) {
79	List<String> authors = new ArrayList<String>();
80
81	String line = getLine(in, "/author/", 0, false);
82	if (line != null) {
83	for (String ln : StringUtils.unhtml(line).split(",")) {
84	if (ln != null && !ln.trim().isEmpty()
85	&& !authors.contains(ln.trim())) {
86	authors.add(ln.trim());
87	}
88	}
89	}
90
91	try {
92	in.reset();
93	} catch (IOException e) {
94	Instance.syserr(e);
95	}
96
97	line = getLine(in, "/artist/", 0, false);
98	if (line != null) {
99	for (String ln : StringUtils.unhtml(line).split(",")) {
100	if (ln != null && !ln.trim().isEmpty()
101	&& !authors.contains(ln.trim())) {
102	authors.add(ln.trim());
103	}
104	}
105	}
106
107	if (authors.isEmpty()) {
108	return null;
109	} else {
110	StringBuilder builder = new StringBuilder();
111	for (String author : authors) {
112	if (builder.length() > 0) {
113	builder.append(", ");
114	}
115
116	builder.append(author);
117	}
118
119	return builder.toString();
120	}
121	}
122
123	@Override
124	protected String getDate(URL source, InputStream in) {
125	String line = getLine(in, "/released/", 0);
126	if (line != null) {
127	line = StringUtils.unhtml(line);
128	return line.trim();
129	}
130
131	return null;
132	}
133
134	@Override
135	protected String getDesc(URL source, InputStream in) {
136	String line = getLine(in, " property=\"og:description\"", 0);
137	if (line != null) {
138	int pos = -1;
139	for (int i = 0; i < 3; i++) {
140	pos = line.indexOf('"', pos + 1);
141	}
142
143	if (pos >= 0) {
144	line = line.substring(pos + 1);
145	pos = line.indexOf('"');
146	if (pos >= 0) {
147	return line.substring(0, pos);
148	}
149	}
150	}
151
152	return null;
153	}
154
155	@Override
156	protected URL getCover(URL url, InputStream in) {
157	String line = getLine(in, " property=\"og:image\"", 0);
158	String cover = null;
159	if (line != null) {
160	int pos = -1;
161	for (int i = 0; i < 3; i++) {
162	pos = line.indexOf('"', pos + 1);
163	}
164
165	if (pos >= 0) {
166	line = line.substring(pos + 1);
167	pos = line.indexOf('"');
168	if (pos >= 0) {
169	cover = line.substring(0, pos);
170	}
171	}
172	}
173
174	if (cover != null) {
175	try {
176	return new URL(cover);
177	} catch (MalformedURLException e) {
178	Instance.syserr(e);
179	}
180	}
181
182	return null;
183	}
184
185	@Override
186	protected List<Entry<String, URL>> getChapters(URL source, InputStream in) {
187	List<Entry<String, URL>> urls = new ArrayList<Entry<String, URL>>();
188
189	String volumeAt = "<h3 class=\"volume\">";
190	String linkAt = "href=\"http://mangafox.me/";
191	String endAt = "<script type=\"text/javascript\">";
192
193	boolean started = false;
194
195	@SuppressWarnings("resource")
196	Scanner scan = new Scanner(in, "UTF-8");
197	scan.useDelimiter("\\n");
198	while (scan.hasNext()) {
199	String line = scan.next();
200
201	if (started && line.contains(endAt)) {
202	break;
203	} else if (!started && line.contains(volumeAt)) {
204	started = true;
205	}
206
207	if (started && line.contains(linkAt)) {
208	// Chapter content url
209	String url = null;
210	int pos = line.indexOf("href=\"");
211	if (pos >= 0) {
212	line = line.substring(pos + "href=\"".length());
213	pos = line.indexOf('\"');
214	if (pos >= 0) {
215	url = line.substring(0, pos);
216	}
217	}
218
219	// Chapter name
220	String name = null;
221	if (scan.hasNext()) {
222	name = StringUtils.unhtml(scan.next()).trim();
223	// Remove the "new" tag if present
224	if (name.endsWith("new")) {
225	name = name.substring(0, name.length() - 3).trim();
226	}
227	}
228
229	// to help with the retry and the originalUrl
230	refresh(url);
231
232	try {
233	final String key = name;
234	final URL value = new URL(url);
235	urls.add(new Entry<String, URL>() {
236	public URL setValue(URL value) {
237	return null;
238	}
239
240	public String getKey() {
241	return key;
242	}
243
244	public URL getValue() {
245	return value;
246	}
247	});
248	} catch (MalformedURLException e) {
249	Instance.syserr(e);
250	}
251	}
252	}
253
254	// the chapters are in reversed order
255	Collections.reverse(urls);
256
257	return urls;
258	}
259
260	@Override
261	protected String getChapterContent(URL source, InputStream in, int number) {
262	StringBuilder builder = new StringBuilder();
263	String base = getCurrentReferer().toString();
264	int pos = base.lastIndexOf('/');
265	base = base.substring(0, pos + 1); // including the '/' at the end
266
267	boolean close = false;
268	while (in != null) {
269	String linkNextLine = getLine(in, "return enlarge()", 0);
270	try {
271	in.reset();
272	} catch (IOException e) {
273	Instance.syserr(e);
274	}
275
276	String linkImageLine = getLine(in, "return enlarge()", 1);
277	String linkNext = null;
278	String linkImage = null;
279	pos = linkNextLine.indexOf("href=\"");
280	if (pos >= 0) {
281	linkNextLine = linkNextLine.substring(pos + "href=\"".length());
282	pos = linkNextLine.indexOf('\"');
283	if (pos >= 0) {
284	linkNext = linkNextLine.substring(0, pos);
285	}
286	}
287	pos = linkImageLine.indexOf("src=\"");
288	if (pos >= 0) {
289	linkImageLine = linkImageLine
290	.substring(pos + "src=\"".length());
291	pos = linkImageLine.indexOf('\"');
292	if (pos >= 0) {
293	linkImage = linkImageLine.substring(0, pos);
294	}
295	}
296
297	if (linkImage != null) {
298	builder.append("[");
299	// to help with the retry and the originalUrl, part 1
300	builder.append(withoutQuery(linkImage));
301	builder.append("]\n");
302	}
303
304	// to help with the retry and the originalUrl, part 2
305	refresh(linkImage);
306
307	if (close) {
308	try {
309	in.close();
310	} catch (IOException e) {
311	Instance.syserr(e);
312	}
313	}
314
315	in = null;
316	if (linkNext != null && !"javascript:void(0);".equals(linkNext)) {
317	URL url;
318	try {
319	url = new URL(base + linkNext);
320	in = openEx(base + linkNext);
321	setCurrentReferer(url);
322	} catch (IOException e) {
323	Instance.syserr(new IOException(
324	"Cannot get the next manga page which is: "
325	+ linkNext, e));
326	}
327	}
328
329	close = true;
330	}
331
332	setCurrentReferer(source);
333	return builder.toString();
334	}
335
336	@Override
337	protected boolean supports(URL url) {
338	return "mangafox.me".equals(url.getHost())
339	\|\| "www.mangafox.me".equals(url.getHost());
340	}
341
342	/**
343	* Refresh the {@link URL} by calling {@link MangaFox#openEx(String)}.
344	*
345	* @param url
346	* the URL to refresh
347	*
348	* @return TRUE if it was refreshed
349	*/
350	private boolean refresh(String url) {
351	try {
352	openEx(url).close();
353	return true;
354	} catch (Exception e) {
355	return false;
356	}
357	}
358
359	/**
360	* Open the URL through the cache, but: retry a second time after 100ms if
361	* it fails, remove the query part of the {@link URL} before saving it to
362	* the cache (so it can be recalled later).
363	*
364	* @param url
365	* the {@link URL}
366	*
367	* @return the resource
368	*
369	* @throws IOException
370	* in case of I/O error
371	*/
372	private InputStream openEx(String url) throws IOException {
373	try {
374	return Instance.getCache().open(new URL(url), this, true,
375	withoutQuery(url));
376	} catch (Exception e) {
377	// second chance
378	try {
379	Thread.sleep(100);
380	} catch (InterruptedException ee) {
381	}
382
383	return Instance.getCache().open(new URL(url), this, true,
384	withoutQuery(url));
385	}
386	}
387
388	/**
389	* Return the same input {@link URL} but without the query part.
390	*
391	* @param url
392	* the inpiut {@link URL} as a {@link String}
393	*
394	* @return the input {@link URL} without query
395	*/
396	private URL withoutQuery(String url) {
397	URL o = null;
398	try {
399	// Remove the query from o (originalUrl), so it can be cached
400	// correctly
401	o = new URL(url);
402	o = new URL(o.getProtocol() + "://" + o.getHost() + o.getPath());
403
404	return o;
405	} catch (MalformedURLException e) {
406	return null;
407	}
408	}
409	}