/*
* Copyright 2006 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.doctool;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
/**
* Takes an input stream and splits it into multiple files. A new file begins
* when a line in the input stream begins with a specific prefix followed by
* whitespace then an absolute or relative file name to create.
*/
public class SplitterJoiner {
public static void main(String[] args) throws IOException {
if (args.length < 2) {
help();
return;
} else if (args[0].equals("split")) {
String[] files = new String[args.length - 1];
System.arraycopy(args, 1, files, 0, args.length - 1);
split(files);
} else if (args[0].equals("join")) {
if (args.length < 4) {
help();
return;
}
String[] files = new String[args.length - 3];
System.arraycopy(args, 3, files, 0, args.length - 3);
merge(args[1], args[2], files);
} else {
if (!args[0].equals("-h") && !args[0].equals("-?")) {
System.err.println("Error: don't know '" + args[0] + "'");
}
help();
return;
}
}
private static void emitFile(PrintWriter out, File outputFile, File inputFile)
throws IOException, ParserConfigurationException, SAXException,
TransformerException {
if (!inputFile.exists()) {
System.err.println("Error: Cannot find input file " + inputFile.getPath());
return;
}
if (inputFile.getCanonicalFile().equals(outputFile)) {
// skip
return;
}
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(inputFile);
writeTopLevelChildren(doc, out);
}
private static void help() {
System.out.println("Usage: SplitterJoiner split infile+");
System.out.println("Usage: SplitterJoiner join tag outfile (infile|dir)+");
System.out.println("\tsplit indicates that inputs file should be split into multiple output files");
System.out.println("\tjoin indicates xml files (or directories) should be merged into one big xml file (on stdout)");
System.out.println("\ttag when joining, the outermost xml tag name");
System.out.println("\toutfile when joining, the file to write the joined output into");
System.out.println("\tinfile if splitting, an input file to split");
System.out.println("\t if joining, a file whose contents should be merged in");
System.out.println("\tdir when joining, a directory whose xml files' contents should be merged in");
}
private static boolean isNewerThan(File file, long lastModified) {
if (file.isFile()) {
return file.lastModified() > lastModified;
}
File[] children = file.listFiles();
if (children != null) {
for (int i = 0, n = children.length; i < n; ++i) {
File child = children[i];
if (isNewerThan(child, lastModified)) {
return true;
}
}
}
return false;
}
private static void merge(String tag, String outputPath, String files[]) {
File outputFile = null;
try {
outputFile = new File(outputPath).getCanonicalFile();
} catch (IOException e) {
e.printStackTrace();
return;
}
// Maybe we don't need to do anything.
//
boolean skipMerge = true;
if (!outputFile.exists()) {
skipMerge = false;
} else {
long outputFileLastModified = outputFile.lastModified();
for (int i = 0, n = files.length; i < n; ++i) {
if (isNewerThan(new File(files[i]), outputFileLastModified)) {
skipMerge = false;
break;
}
}
}
if (skipMerge) {
// Nothing to do.
//
return;
}
try {
PrintWriter out = new PrintWriter(new FileWriter(outputFile), true);
out.println("<?xml version='1.0'?>");
out.println("<" + tag + ">");
for (int i = 0; i < files.length; i++) {
File file = new File(files[i]);
if (file.isFile()) {
emitFile(out, outputFile, file);
} else {
File[] children = file.listFiles();
if (children != null) {
for (int j = 0; j < children.length; ++j) {
if (children[j].isFile()
&& children[j].getPath().endsWith(".xml")) {
emitFile(out, outputFile, children[j]);
}
}
}
}
}
out.println("</" + tag + ">");
out.close();
} catch (IOException e) {
outputFile.deleteOnExit();
e.printStackTrace();
} catch (ParserConfigurationException e) {
outputFile.deleteOnExit();
e.printStackTrace();
} catch (SAXException e) {
outputFile.deleteOnExit();
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
}
}
private static void split(String[] files) throws IOException {
String prefix = null;
File inputFile = null;
for (int i = 0; i < files.length; i++) {
BufferedReader reader = null;
try {
// Open the reader.
//
String file = files[i];
inputFile = new File(file);
if (!inputFile.exists()) {
System.err.println("Error: Cannot find input file "
+ inputFile.getPath());
return;
}
reader = new BufferedReader(new FileReader(inputFile));
// Parse the input
//
File outFile = null;
PrintWriter writer = null;
String line = reader.readLine();
while (line != null) {
if (prefix == null) {
// Learn the prefix.
//
prefix = line.trim();
if (prefix.length() == 0) {
// The first line with anything on it counts as the prefix.
//
prefix = null;
}
} else if (line.startsWith(prefix)) {
// Close the current writer.
//
if (writer != null) {
writer.close();
}
// Create the next writer.
//
String outPath = line.substring(prefix.length()).trim();
outFile = new File(outPath);
if (!outFile.isAbsolute()) {
// Make the created file relative to the input file.
//
File absoluteParentDir = inputFile.getCanonicalFile().getParentFile();
outFile = new File(absoluteParentDir, outPath);
// Ignore result since the next line will fail if the directory
// doesn't exist.
outFile.getParentFile().mkdirs();
}
writer = new PrintWriter(new FileWriter(outFile), true);
writer.println("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">");
} else if (writer != null) {
// Write this line to the current file.
//
writer.println(line);
} else {
// Ignored -- haven't yet seen a starting prefix.
//
}
line = reader.readLine();
}
if (writer != null) {
writer.close();
}
} finally {
// Close the current reader, if any.
if (reader != null) {
reader.close();
}
}
}
}
private static void writeTopLevelChildren(Document doc, PrintWriter out)
throws TransformerException {
StreamResult result = new StreamResult(out);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.setOutputProperty(
javax.xml.transform.OutputKeys.OMIT_XML_DECLARATION, "yes");
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount",
"4");
Node child = doc.getDocumentElement().getFirstChild();
while (child != null) {
DOMSource domSource = new DOMSource(child);
transformer.transform(domSource, result);
child = child.getNextSibling();
}
}
}