unicodetools/com/ibm/rbm/RBReporterScanner.java - external/github.com/unicode-org/icu - Git at Google

 /*
  *****************************************************************************
  * Copyright (C) 2000-2007, International Business Machines Corporation and  *
  * others. All Rights Reserved.                                              *
  *****************************************************************************
  */
 package com.ibm.rbm;


 import java.io.*;
 import java.util.*;

 import org.apache.xerces.parsers.DOMParser;
 import org.w3c.dom.*;
 import org.xml.sax.*;

 /**
  * RBReporterScaner is a utility class for RBReporter. It creates a report from an xml settings
  * file that scans code for resources and compares them against a resource bundle.
  *
  * @author Jared Jackson
  * @see com.ibm.rbm.RBReporter
  */
 public class RBReporterScanner {
 	private Bundle       bundle;
 	private Document     config;
 	private Hashtable    fileRules;
 	private Hashtable    parseRules;
 	private Hashtable    results;
 	private Hashtable    missing;
 	private boolean      resultsFound;

 	protected RBReporterScanner(Bundle bundle, File configFile) throws IOException {
 		resultsFound = false;
 		this.bundle = bundle;

 		try {
 			InputSource is = new InputSource(new FileInputStream(configFile));
 			DOMParser parser = new DOMParser();
 			parser.parse(is);
 			config = parser.getDocument();
 		} catch (SAXException saxe) {
 			throw new IOException("Illegal XML Document: " + saxe.getMessage());
 		}

 		Element root = config.getDocumentElement();
 		fileRules = getFileRules(root);
 		parseRules = getParseRules(root);

 		results = new Hashtable();
 		Enumeration keys = bundle.allItems.keys();
 		while (keys.hasMoreElements()) {
 			String key = (String)keys.nextElement();
 			BundleItem item = (BundleItem)bundle.allItems.get(key);
 			results.put(key, new ScanResult(item));
 		}

 		missing = new Hashtable();
 	}

 	protected int getNumberResourcesFound() {
 		return results.size();
 	}

 	protected int getNumberMissingResources() {
 		return missing.size();
 	}

 	protected int getNumberUnusedResources() {
 		int count = 0;
 		Enumeration elems = results.elements();
 		while (elems.hasMoreElements()) {
 			ScanResult result = (ScanResult)elems.nextElement();
 			if (result.getOccurances().size() < 1) count++;
 		}
 		return count;
 	}

 	protected Vector getMissingResources() {
 		Enumeration elems = missing.elements();
 		Vector v = new Vector();
 		while (elems.hasMoreElements())
 			v.addElement(elems.nextElement());
 		return v;
 	}

 	protected Vector getUnusedResources() {
 		Enumeration elems = results.elements();
 		Vector v = new Vector();
 		while (elems.hasMoreElements()) {
 			ScanResult result = (ScanResult)elems.nextElement();
 			if (result.getOccurances().size() < 1) {
 				v.addElement(result);
 			}
 		}
 		return v;
 	}

 	protected boolean performScan() throws IOException {
 		resultsFound = false;

 		Element root = config.getDocumentElement();
 		NodeList nl = root.getElementsByTagName("Scan");
 		if (nl.getLength() < 1) return resultsFound;
 		Element scan_elem = (Element)nl.item(0);
 		nl = scan_elem.getElementsByTagName("Directory");
 		for (int i=0; i < nl.getLength(); i++) {
 			Element dir_elem = (Element)nl.item(i);
 			File directory = new File(dir_elem.getAttribute("location"));
 			boolean recurse = dir_elem.getAttribute("recurse_directories").equalsIgnoreCase("true");
 			NodeList rules_list = dir_elem.getElementsByTagName("Rules");
 			if (rules_list.getLength() < 1) continue;
 			Element rules_elem = (Element)rules_list.item(0);
 			NodeList frules_list = rules_elem.getElementsByTagName("ApplyFileRule");
 			// For each file rule
 			for (int j=0; j < frules_list.getLength(); j++) {
 				Element frule_elem = (Element)frules_list.item(j);
 				FileRule frule = (FileRule)fileRules.get(frule_elem.getAttribute("name"));
 				if (frule == null) continue;
 				NodeList prules_list = frule_elem.getElementsByTagName("ApplyParseRule");
 				Vector prules_v = new Vector();
 				// For each parse rule
 				for (int k=0; k < prules_list.getLength(); k++) {
 					Element prule_elem = (Element)prules_list.item(k);
 					ParseRule prule = (ParseRule)parseRules.get(prule_elem.getAttribute("name"));
 					if (prule == null) continue;
 					prules_v.addElement(prule);
 				}
 				if (prules_v.size() < 1) continue;
 				scanDirectory(directory, frule, prules_v, recurse);
 			}
 		}

 		return resultsFound;
 	}

 	private void scanDirectory(File directory, FileRule frule, Vector prules, boolean recurse) throws IOException {

 		// Recursion step
 		if (recurse) {
 			File children[] = directory.listFiles(new java.io.FileFilter(){
 				public boolean accept(File f) {
 					return f.isDirectory();
 				}

 				public String getDescription() {
 					return "";
 				}
 			});
 			for (int i=0; i < children.length; i++) {
 				File new_directory = children[i];
 				scanDirectory(new_directory, frule, prules, recurse);
 			}
 		}
 		// Go through each acceptable file
 		File children[] = directory.listFiles();
 		for (int i=0; i < children.length; i++) {
 			File f = children[i];
 			if (f.isDirectory() || !(frule.applyRule(f.getName()))) continue;
 			FileReader fr = new FileReader(f);
 			BufferedReader br = new BufferedReader(fr);
 			String line = null;
 			int line_count = 0;
 			// Read the file line by line
 			while ((line = br.readLine()) != null) {
 				line_count++;
 				Vector findings = new Vector();
 				// Apply all parse rules to each line
 				for (int j=0; j < prules.size(); j++) {
 					ParseRule prule = (ParseRule)prules.elementAt(j);
 					Vector temp_results = prule.applyRule(line);
 					for (int k=0; k < temp_results.size(); k++) {
 						findings.addElement(temp_results.elementAt(k));
 					}
 				}
 				for (int j=0; j < findings.size(); j++) {
 					String name = (String)findings.elementAt(j);
 					Occurance occ = new Occurance(f.getName(), f.getAbsolutePath(), line_count);
 					// If the name is found in the resource bundles derived hashtable
 					if (results.containsKey(name)) {
 						ScanResult scan_res = (ScanResult)results.get(name);
 						scan_res.addOccurance(occ);
 					} else {
 						// Add it to the missing results
 						ScanResult scan_res = new ScanResult(new BundleItem(null, name, "*unknown*"));
 						scan_res.addOccurance(occ);
 						missing.put(name, scan_res);
 						results.put(name, scan_res);
 					}
 				}
 			}
 		}
 	}

 	private Hashtable getFileRules(Element root) {
 		Hashtable result = new Hashtable();
 		NodeList frules_list = root.getElementsByTagName("FileRules");
 		Element frules_elem = null;
 		if (frules_list.getLength() > 0) frules_elem = (Element)frules_list.item(0);
 		if (frules_elem == null) return result;
 		frules_list = frules_elem.getElementsByTagName("FileRule");
 		for (int i=0; i < frules_list.getLength(); i++) {
 			Element elem = (Element)frules_list.item(i);
 			FileRule frule = new FileRule(elem.getAttribute("name"), elem.getAttribute("starts_with"),
 										  elem.getAttribute("ends_with"), elem.getAttribute("contains"));
 			result.put(elem.getAttribute("name"), frule);
 		}
 		return result;
 	}

 	private Hashtable getParseRules(Element root) {
 		Hashtable result = new Hashtable();
 		NodeList prules_list = root.getElementsByTagName("ParseRules");
 		Element prules_elem = null;
 		if (prules_list.getLength() > 0)
 			prules_elem = (Element)prules_list.item(0);
 		if (prules_elem == null)
 			return result;
 		prules_list = prules_elem.getElementsByTagName("ParseRule");
 		for (int i=0; i < prules_list.getLength(); i++) {
 			Element elem = (Element)prules_list.item(i);
 			ParseRule prule = new ParseRule(elem.getAttribute("name"), elem.getAttribute("follows"),
 											elem.getAttribute("precedes"));
 			result.put(elem.getAttribute("name"), prule);
 		}
 		return result;
 	}
 }

 class FileRule {
 	String name;
 	String starts_with;
 	String ends_with;
 	String contains;

 	FileRule(String name, String starts_with, String ends_with, String contains) {
 		this.name = name;
 		this.starts_with = starts_with;
 		this.ends_with = ends_with;
 		this.contains = contains;
 	}

 	boolean applyRule(String source) {
 		boolean accept = true;
 		if (starts_with != null && starts_with.length() > 0 && !(source.startsWith(starts_with))) accept = false;
 		if (ends_with != null && ends_with.length() > 0 && !(source.endsWith(ends_with))) accept = false;
 		if (contains != null && contains.length() > 0 && source.indexOf(contains) < 0) accept = false;
 		return accept;
 	}
 }

 class ParseRule {
 	String name;
 	String before;
 	String after;

 	ParseRule(String name, String before, String after) {
 		this.name = name;
 		this.before = before;
 		this.after = after;
 	}

 	// returns the vector of strings found after before and before after

 	Vector applyRule(String source) {
 		Vector v = new Vector();
 		if (before != null && before.length() > 0) {
 			if (after != null && after.length() > 0) {
 				// Both before and after non-empty
 				int before_index = -1;
 				int after_index = -1;
 				while ((before_index = source.indexOf(before, ++before_index)) >= 0) {
 					//before_index = source.indexOf(before, before_index);
 					after_index = -1;
 					after_index = source.indexOf(after, before_index + before.length()+1);
 					if (after_index < 0 || before_index < 0 || before.length() < 0) {
 					    break;
 					}
 					v.addElement(source.substring(before_index + before.length(), after_index));
 					before_index = after_index;
 				}
 			} else {
 				// Before non-empty, after empty
 				int index = -1;
 				while (source.indexOf(before, ++index) >= 0) {
 					index = source.indexOf(before, index);
 					String result = source.substring(index + before.length(), source.length());
 					if (result != null && result.length() > 0) v.addElement(result);
 				}
 			}
 		} else if (after != null && after.length() > 0) {
 			// Before empty, after not
 			int index = -1;
 			while (source.indexOf(after, ++index) >= 0) {
 				index = source.indexOf(before, index);
 				String result = source.substring(0, index);
 				if (result != null && result.length() > 0) v.addElement(result);
 			}
 		} else {
 			// Before and after empty
 			v.addElement(source);
 		}
 		return v;
 	}
 }
	/*
	*****************************************************************************
	* Copyright (C) 2000-2007, International Business Machines Corporation and *
	* others. All Rights Reserved. *
	*****************************************************************************
	*/
	package com.ibm.rbm;


	import java.io.*;
	import java.util.*;

	import org.apache.xerces.parsers.DOMParser;
	import org.w3c.dom.*;
	import org.xml.sax.*;

	/**
	* RBReporterScaner is a utility class for RBReporter. It creates a report from an xml settings
	* file that scans code for resources and compares them against a resource bundle.
	*
	* @author Jared Jackson
	* @see com.ibm.rbm.RBReporter
	*/
	public class RBReporterScanner {
	private Bundle bundle;
	private Document config;
	private Hashtable fileRules;
	private Hashtable parseRules;
	private Hashtable results;
	private Hashtable missing;
	private boolean resultsFound;

	protected RBReporterScanner(Bundle bundle, File configFile) throws IOException {
	resultsFound = false;
	this.bundle = bundle;

	try {
	InputSource is = new InputSource(new FileInputStream(configFile));
	DOMParser parser = new DOMParser();
	parser.parse(is);
	config = parser.getDocument();
	} catch (SAXException saxe) {
	throw new IOException("Illegal XML Document: " + saxe.getMessage());
	}

	Element root = config.getDocumentElement();
	fileRules = getFileRules(root);
	parseRules = getParseRules(root);

	results = new Hashtable();
	Enumeration keys = bundle.allItems.keys();
	while (keys.hasMoreElements()) {
	String key = (String)keys.nextElement();
	BundleItem item = (BundleItem)bundle.allItems.get(key);
	results.put(key, new ScanResult(item));
	}

	missing = new Hashtable();
	}

	protected int getNumberResourcesFound() {
	return results.size();
	}

	protected int getNumberMissingResources() {
	return missing.size();
	}

	protected int getNumberUnusedResources() {
	int count = 0;
	Enumeration elems = results.elements();
	while (elems.hasMoreElements()) {
	ScanResult result = (ScanResult)elems.nextElement();
	if (result.getOccurances().size() < 1) count++;
	}
	return count;
	}

	protected Vector getMissingResources() {
	Enumeration elems = missing.elements();
	Vector v = new Vector();
	while (elems.hasMoreElements())
	v.addElement(elems.nextElement());
	return v;
	}

	protected Vector getUnusedResources() {
	Enumeration elems = results.elements();
	Vector v = new Vector();
	while (elems.hasMoreElements()) {
	ScanResult result = (ScanResult)elems.nextElement();
	if (result.getOccurances().size() < 1) {
	v.addElement(result);
	}
	}
	return v;
	}

	protected boolean performScan() throws IOException {
	resultsFound = false;

	Element root = config.getDocumentElement();
	NodeList nl = root.getElementsByTagName("Scan");
	if (nl.getLength() < 1) return resultsFound;
	Element scan_elem = (Element)nl.item(0);
	nl = scan_elem.getElementsByTagName("Directory");
	for (int i=0; i < nl.getLength(); i++) {
	Element dir_elem = (Element)nl.item(i);
	File directory = new File(dir_elem.getAttribute("location"));
	boolean recurse = dir_elem.getAttribute("recurse_directories").equalsIgnoreCase("true");
	NodeList rules_list = dir_elem.getElementsByTagName("Rules");
	if (rules_list.getLength() < 1) continue;
	Element rules_elem = (Element)rules_list.item(0);
	NodeList frules_list = rules_elem.getElementsByTagName("ApplyFileRule");
	// For each file rule
	for (int j=0; j < frules_list.getLength(); j++) {
	Element frule_elem = (Element)frules_list.item(j);
	FileRule frule = (FileRule)fileRules.get(frule_elem.getAttribute("name"));
	if (frule == null) continue;
	NodeList prules_list = frule_elem.getElementsByTagName("ApplyParseRule");
	Vector prules_v = new Vector();
	// For each parse rule
	for (int k=0; k < prules_list.getLength(); k++) {
	Element prule_elem = (Element)prules_list.item(k);
	ParseRule prule = (ParseRule)parseRules.get(prule_elem.getAttribute("name"));
	if (prule == null) continue;
	prules_v.addElement(prule);
	}
	if (prules_v.size() < 1) continue;
	scanDirectory(directory, frule, prules_v, recurse);
	}
	}

	return resultsFound;
	}

	private void scanDirectory(File directory, FileRule frule, Vector prules, boolean recurse) throws IOException {

	// Recursion step
	if (recurse) {
	File children[] = directory.listFiles(new java.io.FileFilter(){
	public boolean accept(File f) {
	return f.isDirectory();
	}

	public String getDescription() {
	return "";
	}
	});
	for (int i=0; i < children.length; i++) {
	File new_directory = children[i];
	scanDirectory(new_directory, frule, prules, recurse);
	}
	}
	// Go through each acceptable file
	File children[] = directory.listFiles();
	for (int i=0; i < children.length; i++) {
	File f = children[i];
	if (f.isDirectory() \|\| !(frule.applyRule(f.getName()))) continue;
	FileReader fr = new FileReader(f);
	BufferedReader br = new BufferedReader(fr);
	String line = null;
	int line_count = 0;
	// Read the file line by line
	while ((line = br.readLine()) != null) {
	line_count++;
	Vector findings = new Vector();
	// Apply all parse rules to each line
	for (int j=0; j < prules.size(); j++) {
	ParseRule prule = (ParseRule)prules.elementAt(j);
	Vector temp_results = prule.applyRule(line);
	for (int k=0; k < temp_results.size(); k++) {
	findings.addElement(temp_results.elementAt(k));
	}
	}
	for (int j=0; j < findings.size(); j++) {
	String name = (String)findings.elementAt(j);
	Occurance occ = new Occurance(f.getName(), f.getAbsolutePath(), line_count);
	// If the name is found in the resource bundles derived hashtable
	if (results.containsKey(name)) {
	ScanResult scan_res = (ScanResult)results.get(name);
	scan_res.addOccurance(occ);
	} else {
	// Add it to the missing results
	ScanResult scan_res = new ScanResult(new BundleItem(null, name, "unknown"));
	scan_res.addOccurance(occ);
	missing.put(name, scan_res);
	results.put(name, scan_res);
	}
	}
	}
	}
	}

	private Hashtable getFileRules(Element root) {
	Hashtable result = new Hashtable();
	NodeList frules_list = root.getElementsByTagName("FileRules");
	Element frules_elem = null;
	if (frules_list.getLength() > 0) frules_elem = (Element)frules_list.item(0);
	if (frules_elem == null) return result;
	frules_list = frules_elem.getElementsByTagName("FileRule");
	for (int i=0; i < frules_list.getLength(); i++) {
	Element elem = (Element)frules_list.item(i);
	FileRule frule = new FileRule(elem.getAttribute("name"), elem.getAttribute("starts_with"),
	elem.getAttribute("ends_with"), elem.getAttribute("contains"));
	result.put(elem.getAttribute("name"), frule);
	}
	return result;
	}

	private Hashtable getParseRules(Element root) {
	Hashtable result = new Hashtable();
	NodeList prules_list = root.getElementsByTagName("ParseRules");
	Element prules_elem = null;
	if (prules_list.getLength() > 0)
	prules_elem = (Element)prules_list.item(0);
	if (prules_elem == null)
	return result;
	prules_list = prules_elem.getElementsByTagName("ParseRule");
	for (int i=0; i < prules_list.getLength(); i++) {
	Element elem = (Element)prules_list.item(i);
	ParseRule prule = new ParseRule(elem.getAttribute("name"), elem.getAttribute("follows"),
	elem.getAttribute("precedes"));
	result.put(elem.getAttribute("name"), prule);
	}
	return result;
	}
	}

	class FileRule {
	String name;
	String starts_with;
	String ends_with;
	String contains;

	FileRule(String name, String starts_with, String ends_with, String contains) {
	this.name = name;
	this.starts_with = starts_with;
	this.ends_with = ends_with;
	this.contains = contains;
	}

	boolean applyRule(String source) {
	boolean accept = true;
	if (starts_with != null && starts_with.length() > 0 && !(source.startsWith(starts_with))) accept = false;
	if (ends_with != null && ends_with.length() > 0 && !(source.endsWith(ends_with))) accept = false;
	if (contains != null && contains.length() > 0 && source.indexOf(contains) < 0) accept = false;
	return accept;
	}
	}

	class ParseRule {
	String name;
	String before;
	String after;

	ParseRule(String name, String before, String after) {
	this.name = name;
	this.before = before;
	this.after = after;
	}

	// returns the vector of strings found after before and before after

	Vector applyRule(String source) {
	Vector v = new Vector();
	if (before != null && before.length() > 0) {
	if (after != null && after.length() > 0) {
	// Both before and after non-empty
	int before_index = -1;
	int after_index = -1;
	while ((before_index = source.indexOf(before, ++before_index)) >= 0) {
	//before_index = source.indexOf(before, before_index);
	after_index = -1;
	after_index = source.indexOf(after, before_index + before.length()+1);
	if (after_index < 0 \|\| before_index < 0 \|\| before.length() < 0) {
	break;
	}
	v.addElement(source.substring(before_index + before.length(), after_index));
	before_index = after_index;
	}
	} else {
	// Before non-empty, after empty
	int index = -1;
	while (source.indexOf(before, ++index) >= 0) {
	index = source.indexOf(before, index);
	String result = source.substring(index + before.length(), source.length());
	if (result != null && result.length() > 0) v.addElement(result);
	}
	}
	} else if (after != null && after.length() > 0) {
	// Before empty, after not
	int index = -1;
	while (source.indexOf(after, ++index) >= 0) {
	index = source.indexOf(before, index);
	String result = source.substring(0, index);
	if (result != null && result.length() > 0) v.addElement(result);
	}
	} else {
	// Before and after empty
	v.addElement(source);
	}
	return v;
	}
	}