Coverage Report

Coverage Report - org.kuali.core.db.torque.KualiXmlToAppData

Classes in this File

Line Coverage

Branch Coverage

Complexity

KualiXmlToAppData

0/140

0/82

5.917

KualiXmlToAppData$ParseStackElement

0/16

0/2

5.917

 package org.kuali.core.db.torque;
 
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Stack;
 import java.util.Vector;
 
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.torque.engine.EngineException;
 import org.apache.torque.engine.database.model.Column;
 import org.apache.torque.engine.database.model.Domain;
 import org.apache.torque.engine.database.model.ForeignKey;
 import org.apache.torque.engine.database.model.Index;
 import org.apache.torque.engine.database.model.Table;
 import org.apache.torque.engine.database.model.Unique;
 import org.apache.torque.engine.database.transform.DTDResolver;
 import org.kuali.core.db.torque.pojo.KualiDatabase;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.Resource;
 import org.xml.sax.Attributes;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 import org.xml.sax.helpers.DefaultHandler;
 
 public class KualiXmlToAppData extends DefaultHandler implements DatabaseParser {
     /** Logging class from commons.logging */
     private static Log log = LogFactory.getLog(KualiXmlToAppData.class);
 
     private KualiDatabase database;
     private Table currTable;
 
     // private View currView;
     // private Sequence currSequence;
     private Column currColumn;
     private ForeignKey currFK;
     private Index currIndex;
     private Unique currUnique;
 
     private boolean firstPass;
     private boolean isExternalSchema;
     private String currentPackage;
     private String currentXmlFile;
     private String defaultPackage;
 
     private static SAXParserFactory saxFactory;
 
     /** remember all files we have already parsed to detect looping. */
     private Vector<String> alreadyReadFiles;
 
     /** this is the stack to store parsing data */
     private Stack<Object> parsingStack = new Stack<Object>();
 
     static {
         saxFactory = SAXParserFactory.newInstance();
         saxFactory.setValidating(true);
     }
 
     /**
      * Creates a new instance for the specified database type.
      * 
      * @param databaseType
      *            The type of database for the application.
      */
     public KualiXmlToAppData(String databaseType) {
         database = new KualiDatabase(databaseType);
         firstPass = true;
     }
 
     /**
      * Creates a new instance for the specified database type.
      * 
      * @param databaseType
      *            The type of database for the application.
      * @param defaultPackage
      *            the default java package used for the om
      */
     public KualiXmlToAppData(String databaseType, String defaultPackage) {
         database = new KualiDatabase(databaseType);
         this.defaultPackage = defaultPackage;
         firstPass = true;
     }
 
     protected InputStream getInputStream(String xmlFile) throws IOException {
         File file = new File(xmlFile);
         if (file.exists()) {
             return new BufferedInputStream(new FileInputStream(file));
         }
         DefaultResourceLoader loader = new DefaultResourceLoader();
         Resource resource = loader.getResource(xmlFile);
         if (resource.exists()) {
             return resource.getInputStream();
         }
         throw new IOException("Unable to locate " + xmlFile);
     }
 
     /**
      * Parses a XML input file and returns a newly created and populated Database structure.
      * 
      * @param xmlFile
      *            The input file to parse.
      * @return Database populated by <code>xmlFile</code>.
      */
     public KualiDatabase parseResource(String location) throws EngineException {
         try {
             // in case I am missing something, make it obvious
             if (!firstPass) {
                 throw new Error("No more double pass");
             }
             // check to see if we alread have parsed the file
             if ((alreadyReadFiles != null) && alreadyReadFiles.contains(location)) {
                 return database;
             } else if (alreadyReadFiles == null) {
                 alreadyReadFiles = new Vector<String>(3, 1);
             }
 
             // remember the file to avoid looping
             alreadyReadFiles.add(location);
 
             currentXmlFile = location;
 
             saxFactory.setValidating(false);
             SAXParser parser = saxFactory.newSAXParser();
 
             InputStream in = null;
             try {
                 in = getInputStream(location);
                 InputSource is = new InputSource(in);
                 is.setSystemId(location);
                 parser.parse(is, this);
             } finally {
                 in.close();
             }
         } catch (SAXParseException e) {
             throw new EngineException("Sax error on line " + e.getLineNumber() + " column " + e.getColumnNumber()
                     + " : " + e.getMessage(), e);
         } catch (Exception e) {
             throw new EngineException(e);
         }
         if (!isExternalSchema) {
             firstPass = false;
         }
         database.doFinalInitialization();
         return database;
     }
 
     /**
      * EntityResolver implementation. Called by the XML parser
      * 
      * @param publicId
      *            The public identifier of the external entity
      * @param systemId
      *            The system identifier of the external entity
      * @return an InputSource for the database.dtd file
      * @see DTDResolver#resolveEntity(String, String)
      */
     public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
         try {
             return new ImpexDTDResolver().resolveEntity(publicId, systemId);
         } catch (Exception e) {
             throw new SAXException(e);
         }
     }
 
     /**
      * Handles opening elements of the xml file.
      * 
      * @param uri
      * @param localName
      *            The local name (without prefix), or the empty string if Namespace processing is not being performed.
      * @param rawName
      *            The qualified name (with prefix), or the empty string if qualified names are not available.
      * @param attributes
      *            The specified or defaulted attributes
      */
     public void startElement(String uri, String localName, String rawName, Attributes attributes) throws SAXException {
         try {
             if (rawName.equals("database")) {
                 if (isExternalSchema) {
                     currentPackage = attributes.getValue("package");
                     if (currentPackage == null) {
                         currentPackage = defaultPackage;
                     }
                 } else {
                     database.loadFromXML(attributes);
                     if (database.getPackage() == null) {
                         database.setPackage(defaultPackage);
                     }
                 }
             } else if (rawName.equals("external-schema")) {
                 String xmlFile = attributes.getValue("filename");
                 if (xmlFile.charAt(0) != '/') {
                     File f = new File(currentXmlFile);
                     xmlFile = new File(f.getParent(), xmlFile).getPath();
                 }
 
                 // put current state onto the stack
                 ParseStackElement.pushState(this);
 
                 isExternalSchema = true;
 
                 parseResource(xmlFile);
                 // get the last state from the stack
                 ParseStackElement.popState(this);
             } else if (rawName.equals("domain")) {
                 Domain domain = new Domain();
                 domain.loadFromXML(attributes, database.getPlatform());
                 database.addDomain(domain);
             } else if (rawName.equals("table")) {
                 currTable = database.addTable(attributes);
                 if (isExternalSchema) {
                     currTable.setForReferenceOnly(true);
                     currTable.setPackage(currentPackage);
                 }
             } else if (rawName.equals("view")) {
                 database.addView(attributes);
             } else if (rawName.equals("sequence")) {
                 database.addSequence(attributes);
             } else if (rawName.equals("column")) {
                 currColumn = currTable.addColumn(attributes);
             } else if (rawName.equals("inheritance")) {
                 currColumn.addInheritance(attributes);
             } else if (rawName.equals("foreign-key")) {
                 currFK = currTable.addForeignKey(attributes);
             } else if (rawName.equals("reference")) {
                 currFK.addReference(attributes);
             } else if (rawName.equals("index")) {
                 currIndex = currTable.addIndex(attributes);
             } else if (rawName.equals("index-column")) {
                 currIndex.addColumn(attributes);
             } else if (rawName.equals("unique")) {
                 currUnique = currTable.addUnique(attributes);
             } else if (rawName.equals("unique-column")) {
                 currUnique.addColumn(attributes);
             } else if (rawName.equals("id-method-parameter")) {
                 currTable.addIdMethodParameter(attributes);
             } else if (rawName.equals("option")) {
                 setOption(attributes);
             }
         } catch (Exception e) {
             throw new SAXException(e);
         }
     }
 
     /**
      * Handles closing elements of the xml file.
      * 
      * @param uri
      * @param localName
      *            The local name (without prefix), or the empty string if Namespace processing is not being performed.
      * @param rawName
      *            The qualified name (with prefix), or the empty string if qualified names are not available.
      */
     public void endElement(String uri, String localName, String rawName) throws SAXException {
         if (log.isDebugEnabled()) {
             log.debug("endElement(" + uri + ", " + localName + ", " + rawName + ") called");
         }
         try {
             // Reset working objects to null to allow option to know
             // which element it is associated with.
             if (rawName.equals("table")) {
                 currTable = null;
             } else if (rawName.equals("view")) {
                 // currView = null;
             } else if (rawName.equals("sequence")) {
                 // currSequence = null;
             } else if (rawName.equals("column")) {
                 currColumn = null;
             } else if (rawName.equals("foreign-key")) {
                 currFK = null;
             } else if (rawName.equals("index")) {
                 currIndex = null;
             } else if (rawName.equals("unique")) {
                 currUnique = null;
             }
         } catch (Exception e) {
             throw new SAXException(e);
         }
     }
 
     public void setOption(Attributes attributes) {
         // Look thru supported model elements in reverse order to
         // find one that this option statement applies to.
 
         String key = attributes.getValue("key");
         String value = attributes.getValue("value");
         if (currUnique != null) {
             currUnique.addOption(key, value);
         } else if (currIndex != null) {
             currIndex.addOption(key, value);
         } else if (currFK != null) {
             currFK.addOption(key, value);
         } else if (currColumn != null) {
             currColumn.addOption(key, value);
         } else if (currTable != null) {
             currTable.addOption(key, value);
         } else { // Must be a db level option.
             database.addOption(key, value);
         }
     }
 
     /**
      * Handles exception which occur when the xml file is parsed
      * 
      * @param e
      *            the exception which occured while parsing
      * @throws SAXException
      *             always
      */
     public void error(SAXParseException e) throws SAXException {
         log.error("Sax parser threw an Exception", e);
         throw new SAXException("Error while parsing " + currentXmlFile + " at line " + e.getLineNumber() + " column "
                 + e.getColumnNumber() + " : " + e.getMessage());
     }
 
     /**
      * When parsing multiple files that use nested <external-schema> tags we need to use a stack to remember some
      * values.
      */
     private static class ParseStackElement {
         private boolean isExternalSchema;
         private String currentPackage;
         private String currentXmlFile;
         private boolean firstPass;
 
         /**
          * 
          * @param parser
          */
         public ParseStackElement(KualiXmlToAppData parser) {
             // remember current state of parent object
             isExternalSchema = parser.isExternalSchema;
             currentPackage = parser.currentPackage;
             currentXmlFile = parser.currentXmlFile;
             firstPass = parser.firstPass;
 
             // push the state onto the stack
             parser.parsingStack.push(this);
         }
 
         /**
          * Removes the top element from the stack and activates the stored state
          * 
          * @param parser
          */
         public static void popState(KualiXmlToAppData parser) {
             if (!parser.parsingStack.isEmpty()) {
                 ParseStackElement elem = (ParseStackElement) parser.parsingStack.pop();
 
                 // activate stored state
                 parser.isExternalSchema = elem.isExternalSchema;
                 parser.currentPackage = elem.currentPackage;
                 parser.currentXmlFile = elem.currentXmlFile;
                 parser.firstPass = elem.firstPass;
             }
         }
 
         /**
          * Stores the current state on the top of the stack.
          * 
          * @param parser
          */
         public static void pushState(KualiXmlToAppData parser) {
             new ParseStackElement(parser);
         }
     }
 
 }

1		package org.kuali.core.db.torque;
2
3		import java.io.BufferedInputStream;
4		import java.io.File;
5		import java.io.FileInputStream;
6		import java.io.IOException;
7		import java.io.InputStream;
8		import java.util.Stack;
9		import java.util.Vector;
10
11		import javax.xml.parsers.SAXParser;
12		import javax.xml.parsers.SAXParserFactory;
13
14		import org.apache.commons.logging.Log;
15		import org.apache.commons.logging.LogFactory;
16		import org.apache.torque.engine.EngineException;
17		import org.apache.torque.engine.database.model.Column;
18		import org.apache.torque.engine.database.model.Domain;
19		import org.apache.torque.engine.database.model.ForeignKey;
20		import org.apache.torque.engine.database.model.Index;
21		import org.apache.torque.engine.database.model.Table;
22		import org.apache.torque.engine.database.model.Unique;
23		import org.apache.torque.engine.database.transform.DTDResolver;
24		import org.kuali.core.db.torque.pojo.KualiDatabase;
25		import org.springframework.core.io.DefaultResourceLoader;
26		import org.springframework.core.io.Resource;
27		import org.xml.sax.Attributes;
28		import org.xml.sax.InputSource;
29		import org.xml.sax.SAXException;
30		import org.xml.sax.SAXParseException;
31		import org.xml.sax.helpers.DefaultHandler;
32
33	0	public class KualiXmlToAppData extends DefaultHandler implements DatabaseParser {
34		/** Logging class from commons.logging */
35	0	private static Log log = LogFactory.getLog(KualiXmlToAppData.class);
36
37		private KualiDatabase database;
38		private Table currTable;
39
40		// private View currView;
41		// private Sequence currSequence;
42		private Column currColumn;
43		private ForeignKey currFK;
44		private Index currIndex;
45		private Unique currUnique;
46
47		private boolean firstPass;
48		private boolean isExternalSchema;
49		private String currentPackage;
50		private String currentXmlFile;
51		private String defaultPackage;
52
53		private static SAXParserFactory saxFactory;
54
55		/** remember all files we have already parsed to detect looping. */
56		private Vector<String> alreadyReadFiles;
57
58		/** this is the stack to store parsing data */
59	0	private Stack<Object> parsingStack = new Stack<Object>();
60
61		static {
62	0	saxFactory = SAXParserFactory.newInstance();
63	0	saxFactory.setValidating(true);
64	0	}
65
66		/**
67		* Creates a new instance for the specified database type.
68		*
69		* @param databaseType
70		* The type of database for the application.
71		*/
72	0	public KualiXmlToAppData(String databaseType) {
73	0	database = new KualiDatabase(databaseType);
74	0	firstPass = true;
75	0	}
76
77		/**
78		* Creates a new instance for the specified database type.
79		*
80		* @param databaseType
81		* The type of database for the application.
82		* @param defaultPackage
83		* the default java package used for the om
84		*/
85	0	public KualiXmlToAppData(String databaseType, String defaultPackage) {
86	0	database = new KualiDatabase(databaseType);
87	0	this.defaultPackage = defaultPackage;
88	0	firstPass = true;
89	0	}
90
91		protected InputStream getInputStream(String xmlFile) throws IOException {
92	0	File file = new File(xmlFile);
93	0	if (file.exists()) {
94	0	return new BufferedInputStream(new FileInputStream(file));
95		}
96	0	DefaultResourceLoader loader = new DefaultResourceLoader();
97	0	Resource resource = loader.getResource(xmlFile);
98	0	if (resource.exists()) {
99	0	return resource.getInputStream();
100		}
101	0	throw new IOException("Unable to locate " + xmlFile);
102		}
103
104		/**
105		* Parses a XML input file and returns a newly created and populated Database structure.
106		*
107		* @param xmlFile
108		* The input file to parse.
109		* @return Database populated by <code>xmlFile</code>.
110		*/
111		public KualiDatabase parseResource(String location) throws EngineException {
112		try {
113		// in case I am missing something, make it obvious
114	0	if (!firstPass) {
115	0	throw new Error("No more double pass");
116		}
117		// check to see if we alread have parsed the file
118	0	if ((alreadyReadFiles != null) && alreadyReadFiles.contains(location)) {
119	0	return database;
120	0	} else if (alreadyReadFiles == null) {
121	0	alreadyReadFiles = new Vector<String>(3, 1);
122		}
123
124		// remember the file to avoid looping
125	0	alreadyReadFiles.add(location);
126
127	0	currentXmlFile = location;
128
129	0	saxFactory.setValidating(false);
130	0	SAXParser parser = saxFactory.newSAXParser();
131
132	0	InputStream in = null;
133		try {
134	0	in = getInputStream(location);
135	0	InputSource is = new InputSource(in);
136	0	is.setSystemId(location);
137	0	parser.parse(is, this);
138		} finally {
139	0	in.close();
140	0	}
141	0	} catch (SAXParseException e) {
142	0	throw new EngineException("Sax error on line " + e.getLineNumber() + " column " + e.getColumnNumber()
143		+ " : " + e.getMessage(), e);
144	0	} catch (Exception e) {
145	0	throw new EngineException(e);
146	0	}
147	0	if (!isExternalSchema) {
148	0	firstPass = false;
149		}
150	0	database.doFinalInitialization();
151	0	return database;
152		}
153
154		/**
155		* EntityResolver implementation. Called by the XML parser
156		*
157		* @param publicId
158		* The public identifier of the external entity
159		* @param systemId
160		* The system identifier of the external entity
161		* @return an InputSource for the database.dtd file
162		* @see DTDResolver#resolveEntity(String, String)
163		*/
164		public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
165		try {
166	0	return new ImpexDTDResolver().resolveEntity(publicId, systemId);
167	0	} catch (Exception e) {
168	0	throw new SAXException(e);
169		}
170		}
171
172		/**
173		* Handles opening elements of the xml file.
174		*
175		* @param uri
176		* @param localName
177		* The local name (without prefix), or the empty string if Namespace processing is not being performed.
178		* @param rawName
179		* The qualified name (with prefix), or the empty string if qualified names are not available.
180		* @param attributes
181		* The specified or defaulted attributes
182		*/
183		public void startElement(String uri, String localName, String rawName, Attributes attributes) throws SAXException {
184		try {
185	0	if (rawName.equals("database")) {
186	0	if (isExternalSchema) {
187	0	currentPackage = attributes.getValue("package");
188	0	if (currentPackage == null) {
189	0	currentPackage = defaultPackage;
190		}
191		} else {
192	0	database.loadFromXML(attributes);
193	0	if (database.getPackage() == null) {
194	0	database.setPackage(defaultPackage);
195		}
196		}
197	0	} else if (rawName.equals("external-schema")) {
198	0	String xmlFile = attributes.getValue("filename");
199	0	if (xmlFile.charAt(0) != '/') {
200	0	File f = new File(currentXmlFile);
201	0	xmlFile = new File(f.getParent(), xmlFile).getPath();
202		}
203
204		// put current state onto the stack
205	0	ParseStackElement.pushState(this);
206
207	0	isExternalSchema = true;
208
209	0	parseResource(xmlFile);
210		// get the last state from the stack
211	0	ParseStackElement.popState(this);
212	0	} else if (rawName.equals("domain")) {
213	0	Domain domain = new Domain();
214	0	domain.loadFromXML(attributes, database.getPlatform());
215	0	database.addDomain(domain);
216	0	} else if (rawName.equals("table")) {
217	0	currTable = database.addTable(attributes);
218	0	if (isExternalSchema) {
219	0	currTable.setForReferenceOnly(true);
220	0	currTable.setPackage(currentPackage);
221		}
222	0	} else if (rawName.equals("view")) {
223	0	database.addView(attributes);
224	0	} else if (rawName.equals("sequence")) {
225	0	database.addSequence(attributes);
226	0	} else if (rawName.equals("column")) {
227	0	currColumn = currTable.addColumn(attributes);
228	0	} else if (rawName.equals("inheritance")) {
229	0	currColumn.addInheritance(attributes);
230	0	} else if (rawName.equals("foreign-key")) {
231	0	currFK = currTable.addForeignKey(attributes);
232	0	} else if (rawName.equals("reference")) {
233	0	currFK.addReference(attributes);
234	0	} else if (rawName.equals("index")) {
235	0	currIndex = currTable.addIndex(attributes);
236	0	} else if (rawName.equals("index-column")) {
237	0	currIndex.addColumn(attributes);
238	0	} else if (rawName.equals("unique")) {
239	0	currUnique = currTable.addUnique(attributes);
240	0	} else if (rawName.equals("unique-column")) {
241	0	currUnique.addColumn(attributes);
242	0	} else if (rawName.equals("id-method-parameter")) {
243	0	currTable.addIdMethodParameter(attributes);
244	0	} else if (rawName.equals("option")) {
245	0	setOption(attributes);
246		}
247	0	} catch (Exception e) {
248	0	throw new SAXException(e);
249	0	}
250	0	}
251
252		/**
253		* Handles closing elements of the xml file.
254		*
255		* @param uri
256		* @param localName
257		* The local name (without prefix), or the empty string if Namespace processing is not being performed.
258		* @param rawName
259		* The qualified name (with prefix), or the empty string if qualified names are not available.
260		*/
261		public void endElement(String uri, String localName, String rawName) throws SAXException {
262	0	if (log.isDebugEnabled()) {
263	0	log.debug("endElement(" + uri + ", " + localName + ", " + rawName + ") called");
264		}
265		try {
266		// Reset working objects to null to allow option to know
267		// which element it is associated with.
268	0	if (rawName.equals("table")) {
269	0	currTable = null;
270	0	} else if (rawName.equals("view")) {
271		// currView = null;
272	0	} else if (rawName.equals("sequence")) {
273		// currSequence = null;
274	0	} else if (rawName.equals("column")) {
275	0	currColumn = null;
276	0	} else if (rawName.equals("foreign-key")) {
277	0	currFK = null;
278	0	} else if (rawName.equals("index")) {
279	0	currIndex = null;
280	0	} else if (rawName.equals("unique")) {
281	0	currUnique = null;
282		}
283	0	} catch (Exception e) {
284	0	throw new SAXException(e);
285	0	}
286	0	}
287
288		public void setOption(Attributes attributes) {
289		// Look thru supported model elements in reverse order to
290		// find one that this option statement applies to.
291
292	0	String key = attributes.getValue("key");
293	0	String value = attributes.getValue("value");
294	0	if (currUnique != null) {
295	0	currUnique.addOption(key, value);
296	0	} else if (currIndex != null) {
297	0	currIndex.addOption(key, value);
298	0	} else if (currFK != null) {
299	0	currFK.addOption(key, value);
300	0	} else if (currColumn != null) {
301	0	currColumn.addOption(key, value);
302	0	} else if (currTable != null) {
303	0	currTable.addOption(key, value);
304		} else { // Must be a db level option.
305	0	database.addOption(key, value);
306		}
307	0	}
308
309		/**
310		* Handles exception which occur when the xml file is parsed
311		*
312		* @param e
313		* the exception which occured while parsing
314		* @throws SAXException
315		* always
316		*/
317		public void error(SAXParseException e) throws SAXException {
318	0	log.error("Sax parser threw an Exception", e);
319	0	throw new SAXException("Error while parsing " + currentXmlFile + " at line " + e.getLineNumber() + " column "
320		+ e.getColumnNumber() + " : " + e.getMessage());
321		}
322
323		/**
324		* When parsing multiple files that use nested <external-schema> tags we need to use a stack to remember some
325		* values.
326		*/
327		private static class ParseStackElement {
328		private boolean isExternalSchema;
329		private String currentPackage;
330		private String currentXmlFile;
331		private boolean firstPass;
332
333		/**
334		*
335		* @param parser
336		*/
337	0	public ParseStackElement(KualiXmlToAppData parser) {
338		// remember current state of parent object
339	0	isExternalSchema = parser.isExternalSchema;
340	0	currentPackage = parser.currentPackage;
341	0	currentXmlFile = parser.currentXmlFile;
342	0	firstPass = parser.firstPass;
343
344		// push the state onto the stack
345	0	parser.parsingStack.push(this);
346	0	}
347
348		/**
349		* Removes the top element from the stack and activates the stored state
350		*
351		* @param parser
352		*/
353		public static void popState(KualiXmlToAppData parser) {
354	0	if (!parser.parsingStack.isEmpty()) {
355	0	ParseStackElement elem = (ParseStackElement) parser.parsingStack.pop();
356
357		// activate stored state
358	0	parser.isExternalSchema = elem.isExternalSchema;
359	0	parser.currentPackage = elem.currentPackage;
360	0	parser.currentXmlFile = elem.currentXmlFile;
361	0	parser.firstPass = elem.firstPass;
362		}
363	0	}
364
365		/**
366		* Stores the current state on the top of the stack.
367		*
368		* @param parser
369		*/
370		public static void pushState(KualiXmlToAppData parser) {
371	0	new ParseStackElement(parser);
372	0	}
373		}
374
375		}