(README update)
[fanfix.git] / src / be / nikiroo / fanfix / Main.java
... / ...
CommitLineData
1package be.nikiroo.fanfix;
2
3import java.io.File;
4import java.io.IOException;
5import java.net.MalformedURLException;
6import java.net.URL;
7
8import be.nikiroo.fanfix.bundles.StringId;
9import be.nikiroo.fanfix.data.Chapter;
10import be.nikiroo.fanfix.data.Story;
11import be.nikiroo.fanfix.output.BasicOutput;
12import be.nikiroo.fanfix.output.BasicOutput.OutputType;
13import be.nikiroo.fanfix.reader.BasicReader;
14import be.nikiroo.fanfix.reader.BasicReader.ReaderType;
15import be.nikiroo.fanfix.supported.BasicSupport;
16import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
17import be.nikiroo.utils.Progress;
18import be.nikiroo.utils.Version;
19import be.nikiroo.utils.ui.UIUtils;
20
21/**
22 * Main program entry point.
23 *
24 * @author niki
25 */
26public class Main {
27 private enum MainAction {
28 IMPORT, EXPORT, CONVERT, READ, READ_URL, LIST, HELP, SET_READER, START, VERSION,
29 }
30
31 /**
32 * Main program entry point.
33 * <p>
34 * Known environment variables:
35 * <ul>
36 * <li>NOUTF: if set to 1 or 'true', the program will prefer non-unicode
37 * {@link String}s when possible</li>
38 * <li>CONFIG_DIR: a path where to look for the <tt>.properties</tt> files
39 * before taking the usual ones; they will also be saved/updated into this
40 * path when the program starts</li>
41 * <li>DEBUG: if set to 1 or 'true', the program will override the DEBUG_ERR
42 * configuration value with 'true'</li>
43 * </ul>
44 * <p>
45 * <ul>
46 * <li>--import [URL]: import into library</li>
47 * <li>--export [id] [output_type] [target]: export story to target</li>
48 * <li>--convert [URL] [output_type] [target] (+info): convert URL into
49 * target</li>
50 * <li>--read [id] ([chapter number]): read the given story from the library
51 * </li>
52 * <li>--read-url [URL] ([chapter number]): convert on the fly and read the
53 * story, without saving it</li>
54 * <li>--list ([type]): list the stories present in the library</li>
55 * <li>--set-reader [reader type]: set the reader type to CLI or LOCAL for
56 * this command</li>
57 * <li>--version: get the version of the program</li>
58 * </ul>
59 *
60 * @param args
61 * see method description
62 */
63 public static void main(String[] args) {
64 String urlString = null;
65 String luid = null;
66 String typeString = null;
67 String chapString = null;
68 String target = null;
69 MainAction action = MainAction.START;
70 Boolean plusInfo = null;
71
72 boolean noMoreActions = false;
73
74 int exitCode = 0;
75 for (int i = 0; exitCode == 0 && i < args.length; i++) {
76 // Action (--) handling:
77 if (!noMoreActions && args[i].startsWith("--")) {
78 if (args[i].equals("--")) {
79 noMoreActions = true;
80 } else {
81 try {
82 action = MainAction.valueOf(args[i].substring(2)
83 .toUpperCase().replace("-", "_"));
84 } catch (Exception e) {
85 Instance.syserr(new IllegalArgumentException(
86 "Unknown action: " + args[i], e));
87 exitCode = 255;
88 }
89 }
90
91 continue;
92 }
93
94 switch (action) {
95 case IMPORT:
96 if (urlString == null) {
97 urlString = args[i];
98 } else {
99 exitCode = 255;
100 }
101 break;
102 case EXPORT:
103 if (luid == null) {
104 luid = args[i];
105 } else if (typeString == null) {
106 typeString = args[i];
107 } else if (target == null) {
108 target = args[i];
109 } else {
110 exitCode = 255;
111 }
112 break;
113 case CONVERT:
114 if (urlString == null) {
115 urlString = args[i];
116 } else if (typeString == null) {
117 typeString = args[i];
118 } else if (target == null) {
119 target = args[i];
120 } else if (plusInfo == null) {
121 if ("+info".equals(args[i])) {
122 plusInfo = true;
123 } else {
124 exitCode = 255;
125 }
126 } else {
127 exitCode = 255;
128 }
129 break;
130 case LIST:
131 if (typeString == null) {
132 typeString = args[i];
133 } else {
134 exitCode = 255;
135 }
136 break;
137 case READ:
138 if (luid == null) {
139 luid = args[i];
140 } else if (chapString == null) {
141 chapString = args[i];
142 } else {
143 exitCode = 255;
144 }
145 break;
146 case READ_URL:
147 if (urlString == null) {
148 urlString = args[i];
149 } else if (chapString == null) {
150 chapString = args[i];
151 } else {
152 exitCode = 255;
153 }
154 break;
155 case HELP:
156 exitCode = 255;
157 break;
158 case SET_READER:
159 exitCode = setReaderType(args[i]);
160 break;
161 case START:
162 exitCode = 255; // not supposed to be selected by user
163 break;
164 case VERSION:
165 exitCode = 255; // no arguments for this option
166 }
167 }
168
169 final Progress mainProgress = new Progress(0, 80);
170 mainProgress.addProgressListener(new Progress.ProgressListener() {
171 private int current = mainProgress.getMin();
172
173 public void progress(Progress progress, String name) {
174 int diff = progress.getProgress() - current;
175 current += diff;
176
177 StringBuilder builder = new StringBuilder();
178 for (int i = 0; i < diff; i++) {
179 builder.append('.');
180 }
181
182 System.err.print(builder.toString());
183
184 if (progress.isDone()) {
185 System.err.println("");
186 }
187 }
188 });
189 Progress pg = new Progress();
190 mainProgress.addProgress(pg, mainProgress.getMax());
191
192 VersionCheck updates = VersionCheck.check();
193 if (updates.isNewVersionAvailable()) {
194 // Sent to syserr so not to cause problem if one tries to capture a
195 // story content in text mode
196 System.err
197 .println("A new version of the program is available at https://github.com/nikiroo/fanfix/releases");
198 System.err.println("");
199 for (Version v : updates.getNewer()) {
200 System.err.println("\tVersion " + v);
201 System.err.println("\t-------------");
202 System.err.println("");
203 for (String item : updates.getChanges().get(v)) {
204 System.err.println("\t- " + item);
205 }
206 System.err.println("");
207 }
208 }
209
210 if (exitCode != 255) {
211 switch (action) {
212 case IMPORT:
213 exitCode = imprt(urlString, pg);
214 updates.ok(); // we consider it read
215 break;
216 case EXPORT:
217 exitCode = export(luid, typeString, target, pg);
218 updates.ok(); // we consider it read
219 break;
220 case CONVERT:
221 exitCode = convert(urlString, typeString, target,
222 plusInfo == null ? false : plusInfo, pg);
223 updates.ok(); // we consider it read
224 break;
225 case LIST:
226 exitCode = list(typeString);
227 break;
228 case READ:
229 exitCode = read(luid, chapString, true);
230 break;
231 case READ_URL:
232 exitCode = read(urlString, chapString, false);
233 break;
234 case HELP:
235 syntax(true);
236 exitCode = 0;
237 break;
238 case SET_READER:
239 break;
240 case VERSION:
241 System.out
242 .println(String.format("Fanfix version %s"
243 + "\nhttps://github.com/nikiroo/fanfix/"
244 + "\n\tWritten by Nikiroo",
245 Version.getCurrentVersion()));
246 updates.ok(); // we consider it read
247 break;
248 case START:
249 UIUtils.setLookAndFeel();
250 BasicReader.setDefaultReaderType(ReaderType.LOCAL);
251 BasicReader.getReader().start(null);
252 break;
253 }
254 }
255
256 if (exitCode == 255) {
257 syntax(false);
258 }
259
260 if (exitCode != 0) {
261 System.exit(exitCode);
262 }
263 }
264
265 /**
266 * Import the given resource into the {@link Library}.
267 *
268 * @param urlString
269 * the resource to import
270 * @param pg
271 * the optional progress reporter
272 *
273 * @return the exit return code (0 = success)
274 */
275 public static int imprt(String urlString, Progress pg) {
276 try {
277 Story story = Instance.getLibrary().imprt(
278 BasicReader.getUrl(urlString), pg);
279 System.out.println(story.getMeta().getLuid() + ": \""
280 + story.getMeta().getTitle() + "\" imported.");
281 } catch (IOException e) {
282 Instance.syserr(e);
283 return 1;
284 }
285
286 return 0;
287 }
288
289 /**
290 * Export the {@link Story} from the {@link Library} to the given target.
291 *
292 * @param luid
293 * the story LUID
294 * @param typeString
295 * the {@link OutputType} to use
296 * @param target
297 * the target
298 * @param pg
299 * the optional progress reporter
300 *
301 * @return the exit return code (0 = success)
302 */
303 public static int export(String luid, String typeString, String target,
304 Progress pg) {
305 OutputType type = OutputType.valueOfNullOkUC(typeString);
306 if (type == null) {
307 Instance.syserr(new Exception(trans(StringId.OUTPUT_DESC,
308 typeString)));
309 return 1;
310 }
311
312 try {
313 Instance.getLibrary().export(luid, type, target, pg);
314 } catch (IOException e) {
315 Instance.syserr(e);
316 return 4;
317 }
318
319 return 0;
320 }
321
322 /**
323 * List the stories of the given type from the {@link Library} (unless NULL
324 * is passed, in which case all stories will be listed).
325 *
326 * @param typeString
327 * the type to list the known stories of, or NULL to list all
328 * stories
329 *
330 * @return the exit return code (0 = success)
331 */
332 private static int list(String type) {
333 BasicReader.getReader().start(type);
334 return 0;
335 }
336
337 /**
338 * Start the CLI reader for this {@link Story}.
339 *
340 * @param story
341 * the LUID of the {@link Story} in the {@link Library} <b>or</b>
342 * the {@link Story} {@link URL}
343 * @param chapString
344 * which {@link Chapter} to read (starting at 1), or NULL to get
345 * the {@link Story} description
346 * @param library
347 * TRUE if the source is the {@link Story} LUID, FALSE if it is a
348 * {@link URL}
349 *
350 * @return the exit return code (0 = success)
351 */
352 private static int read(String story, String chapString, boolean library) {
353 try {
354 BasicReader reader = BasicReader.getReader();
355 if (library) {
356 reader.setStory(story, null);
357 } else {
358 reader.setStory(BasicReader.getUrl(story), null);
359 }
360
361 if (chapString != null) {
362 try {
363 reader.read(Integer.parseInt(chapString));
364 } catch (NumberFormatException e) {
365 Instance.syserr(new IOException(
366 "Chapter number cannot be parsed: " + chapString, e));
367 return 2;
368 }
369 } else {
370 reader.read();
371 }
372 } catch (IOException e) {
373 Instance.syserr(e);
374 return 1;
375 }
376
377 return 0;
378 }
379
380 /**
381 * Convert the {@link Story} into another format.
382 *
383 * @param urlString
384 * the source {@link Story} to convert
385 * @param typeString
386 * the {@link OutputType} to convert to
387 * @param target
388 * the target file
389 * @param infoCover
390 * TRUE to also export the cover and info file, even if the given
391 * {@link OutputType} does not usually save them
392 * @param pg
393 * the optional progress reporter
394 *
395 * @return the exit return code (0 = success)
396 */
397 private static int convert(String urlString, String typeString,
398 String target, boolean infoCover, Progress pg) {
399 int exitCode = 0;
400
401 String sourceName = urlString;
402 try {
403 URL source = BasicReader.getUrl(urlString);
404 sourceName = source.toString();
405 if (source.toString().startsWith("file://")) {
406 sourceName = sourceName.substring("file://".length());
407 }
408
409 OutputType type = OutputType.valueOfAllOkUC(typeString);
410 if (type == null) {
411 Instance.syserr(new IOException(trans(
412 StringId.ERR_BAD_OUTPUT_TYPE, typeString)));
413
414 exitCode = 2;
415 } else {
416 try {
417 BasicSupport support = BasicSupport.getSupport(source);
418
419 if (support != null) {
420 Progress pgIn = new Progress();
421 Progress pgOut = new Progress();
422 if (pg != null) {
423 pg.setMax(2);
424 pg.addProgress(pgIn, 1);
425 pg.addProgress(pgOut, 1);
426 }
427
428 Story story = support.process(source, pgIn);
429 try {
430 target = new File(target).getAbsolutePath();
431 BasicOutput.getOutput(type, infoCover).process(
432 story, target, pgOut);
433 } catch (IOException e) {
434 Instance.syserr(new IOException(trans(
435 StringId.ERR_SAVING, target), e));
436 exitCode = 5;
437 }
438 } else {
439 Instance.syserr(new IOException(trans(
440 StringId.ERR_NOT_SUPPORTED, source)));
441
442 exitCode = 4;
443 }
444 } catch (IOException e) {
445 Instance.syserr(new IOException(trans(StringId.ERR_LOADING,
446 sourceName), e));
447 exitCode = 3;
448 }
449 }
450 } catch (MalformedURLException e) {
451 Instance.syserr(new IOException(trans(StringId.ERR_BAD_URL,
452 sourceName), e));
453 exitCode = 1;
454 }
455
456 return exitCode;
457 }
458
459 /**
460 * Simple shortcut method to call {link Instance#getTrans()#getString()}.
461 *
462 * @param id
463 * the ID to translate
464 *
465 * @return the translated result
466 */
467 private static String trans(StringId id, Object... params) {
468 return Instance.getTrans().getString(id, params);
469 }
470
471 /**
472 * Display the correct syntax of the program to the user to stdout, or an
473 * error message if the syntax used was wrong on stderr.
474 *
475 * @param showHelp
476 * TRUE to show the syntax help, FALSE to show "syntax error"
477 */
478 private static void syntax(boolean showHelp) {
479 if (showHelp) {
480 StringBuilder builder = new StringBuilder();
481 for (SupportType type : SupportType.values()) {
482 builder.append(trans(StringId.ERR_SYNTAX_TYPE, type.toString(),
483 type.getDesc()));
484 builder.append('\n');
485 }
486
487 String typesIn = builder.toString();
488 builder.setLength(0);
489
490 for (OutputType type : OutputType.values()) {
491 builder.append(trans(StringId.ERR_SYNTAX_TYPE, type.toString(),
492 type.getDesc(true)));
493 builder.append('\n');
494 }
495
496 String typesOut = builder.toString();
497
498 System.out.println(trans(StringId.HELP_SYNTAX, typesIn, typesOut));
499 } else {
500 System.err.println(trans(StringId.ERR_SYNTAX));
501 }
502 }
503
504 /**
505 * Set the default reader type for this session only (it can be changed in
506 * the configuration file, too, but this value will override it).
507 *
508 * @param readerTypeString
509 * the type
510 */
511 private static int setReaderType(String readerTypeString) {
512 try {
513 ReaderType readerType = ReaderType.valueOf(readerTypeString
514 .toUpperCase());
515 BasicReader.setDefaultReaderType(readerType);
516 return 0;
517 } catch (IllegalArgumentException e) {
518 Instance.syserr(new IOException("Unknown reader type: "
519 + readerTypeString, e));
520 return 1;
521 }
522 }
523}