private void removeNodes(NodeList nl) {
int count = nl.getLength();
for (int i = 0; i < count; i++) {
Node node = nl.item(i);
Node parent = node.getParentNode();
if (parent == null) continue;
parent.removeChild(node);
}
}
private List<Node> getChildNodes(Node parentNode, String tagName) {
List<Node> nodeList = new ArrayList<Node>();
for (Node child = parentNode.getFirstChild(); child != null; child = child.getNextSibling()) {
if (child.getNodeType() == Node.ELEMENT_NODE && tagName.equals(child.getNodeName())) {
nodeList.add(child);
}
}
return nodeList;
}
private String getXPath(Node node, String xpath) {
if (node == null) {
return "";
}
String nodeName = node.getNodeName();
Node parent = node.getParentNode();
if (parent == null) {
return xpath;
}
return getXPath(parent, "/" + nodeName + xpath);
}
private void setXmlEntry(Document doc, Node opSet) {
NodeList targetNodes = findNodes(doc, opSet);
NodeList valueNodes = getValueNodes(opSet);
if (targetNodes == null) {
return;
}
int targetNodesCount = targetNodes.getLength();
for (int i = 0; i < targetNodesCount; i++) {
Node target = targetNodes.item(i);
for (Node child; (child = target.getFirstChild()) != null; target.removeChild(child)) ;
appendNodes(doc, target, valueNodes);
}
}
private void call(Node operation)
throws ParserConfigurationException, TransformerConfigurationException {
String opName = operation.getNodeName();
if (opName.equals("call")) {
String script =
Utils.combine(Utils.getParentDir(this.currentScript), operation.getTextContent());
call(script);
} else if (opName.equals("apply")) processApply(operation);
else if (opName.equals("xml")) processXml(operation);
else if (opName.equals("txt")) processTxt(operation);
else if (opName.equals("copy")) processCopy(operation);
else if (opName.equals("delete")) processDelete(operation);
}
private void replaceXmlEntry(Document doc, Node opReplace) {
NodeList targetNodes = findNodes(doc, opReplace);
NodeList valueNodes = getValueNodes(opReplace);
if (targetNodes == null) {
return;
}
int targetNodesCount = targetNodes.getLength();
for (int i = 0; i < targetNodesCount; i++) {
Node target = targetNodes.item(i);
Node parent = target.getParentNode();
if (parent == null) continue;
parent.removeChild(target);
appendNodes(doc, parent, valueNodes);
}
}
private void call(String script)
throws ParserConfigurationException, TransformerConfigurationException {
File callerScript = this.currentScript;
Document doc = null;
try {
this.currentScript = new File(script);
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
doc = db.parse(this.currentScript);
} catch (Exception ex) {
this.currentScript = callerScript;
Utils.onError(new Error.FileParse(script));
return;
}
NodeList operations = doc.getDocumentElement().getChildNodes();
for (int i = 0; i < operations.getLength(); i++) {
Node operation = operations.item(i);
if (operation.getNodeType() != Node.ELEMENT_NODE) continue;
call(operation);
}
this.currentScript = callerScript;
}
private void processDelete(Node operation) {
String path = absolutePath(operation.getTextContent());
File target = new File(path);
if (!target.exists()) {
Utils.onError(new Error.FileNotFound(target.getPath()));
return;
}
try {
if (target.isDirectory()) {
FileUtils.deleteDirectory(target);
} else {
FileUtils.forceDelete(target);
}
} catch (IOException ex) {
Utils.onError(new Error.FileDelete(target.getPath()));
}
}
private void appendNodes(Document doc, Node target, NodeList nodes) {
for (int i = 0; i < nodes.getLength(); i++) {
Node node = nodes.item(i);
target.appendChild(doc.importNode(node, true));
}
}
private void processTxt(Node operation) {
List<Node> targets = getChildNodes(operation, "target");
List<Node> optionNodes = getChildNodes(operation, "opt");
List<Node> separatorNode = getChildNodes(operation, "separator");
if (targets.isEmpty() || optionNodes.isEmpty()) {
return;
}
String defaultSeparator = "=";
String globalSeparator = defaultSeparator;
if (!separatorNode.isEmpty()) {
globalSeparator = separatorNode.get(0).getTextContent();
if (globalSeparator.length() != 1) {
globalSeparator = defaultSeparator;
}
}
Map<String, String> options = new HashMap<String, String>();
Map<String, String> processedOptions = new HashMap<String, String>();
for (int i = 0; i < optionNodes.size(); i++) {
Node option = optionNodes.get(i);
String name = option.getAttributes().getNamedItem("name").getNodeValue();
String value = option.getTextContent();
if (options.containsKey(name)) {
options.remove(name);
}
options.put(name, value);
}
for (int t = 0; t < targets.size(); t++) {
File target = new File(absolutePath(targets.get(t).getTextContent()));
File tmpFile = new File(Utils.timestamp());
BufferedWriter bw = null;
BufferedReader br = null;
try {
Node separatorAttr = targets.get(t).getAttributes().getNamedItem("separator");
String separator = (separatorAttr == null) ? globalSeparator : separatorAttr.getNodeValue();
if (separator.length() != 1) {
separator = globalSeparator;
}
bw = new BufferedWriter(new FileWriter(tmpFile));
if (target.exists()) {
br = new BufferedReader(new FileReader(target));
for (String line; (line = br.readLine()) != null; ) {
String[] parts = line.split(separator);
if (parts.length < 2) {
bw.write(line);
bw.newLine();
continue;
}
String optName = parts[0].trim();
if (options.containsKey(optName)) {
String optValue = options.get(optName);
bw.write(optName + " " + separator + " " + optValue);
bw.newLine();
processedOptions.put(optName, optValue);
options.remove(optName);
} else if (processedOptions.containsKey(optName)) {
bw.write(optName + " " + separator + " " + processedOptions.get(optName));
bw.newLine();
} else {
bw.write(line);
bw.newLine();
}
}
br.close();
}
for (Map.Entry<String, String> entry : options.entrySet()) {
bw.write(entry.getKey() + " " + separator + " " + entry.getValue());
bw.newLine();
}
bw.close();
FileUtils.copyFile(tmpFile, target);
FileUtils.forceDelete(tmpFile);
} catch (IOException ex) {
Utils.onError(new Error.WriteTxtConfig(target.getPath()));
}
}
}