001: /*
002: * CM Model Generator
003: */
004:
005: package com.icesoft.jsfmeta.eclipse;
006:
007: import com.icesoft.jsfmeta.MetadataXmlParser;
008: import com.icesoft.jsfmeta.util.GeneratorUtil;
009: import com.sun.rave.jsfmeta.beans.ComponentBean;
010: import com.sun.rave.jsfmeta.beans.FacesConfigBean;
011: import com.sun.rave.jsfmeta.beans.PropertyBean;
012: import com.sun.rave.jsfmeta.beans.RenderKitBean;
013: import com.sun.rave.jsfmeta.beans.RendererBean;
014: import java.io.File;
015: import java.io.FileNotFoundException;
016: import java.io.FileOutputStream;
017: import java.io.IOException;
018: import java.net.URL;
019: import java.util.HashMap;
020: import java.util.Map;
021: import java.util.Properties;
022: import java.util.logging.Level;
023: import java.util.logging.Logger;
024: import javax.faces.render.RenderKitFactory;
025: import javax.xml.parsers.DocumentBuilder;
026: import javax.xml.parsers.DocumentBuilderFactory;
027: import javax.xml.parsers.ParserConfigurationException;
028: import javax.xml.transform.Transformer;
029: import javax.xml.transform.TransformerConfigurationException;
030: import javax.xml.transform.TransformerException;
031: import javax.xml.transform.TransformerFactory;
032: import javax.xml.transform.TransformerFactoryConfigurationError;
033: import javax.xml.transform.dom.DOMSource;
034: import javax.xml.transform.stream.StreamResult;
035: import org.w3c.dom.DOMException;
036: import org.w3c.dom.Document;
037: import org.w3c.dom.Element;
038: import org.w3c.dom.NamedNodeMap;
039: import org.w3c.dom.Node;
040: import org.w3c.dom.NodeList;
041: import org.xml.sax.SAXException;
042:
043: public class CMGenerator {
044:
045: private static Logger log = Logger.getLogger(CMGenerator.class
046: .getName());
047: private Document cmDoc;
048: private Map propertyDisplayLabelMap = new HashMap();
049: private String cmOutputFolder;
050:
051: public CMGenerator() {
052: }
053:
054: public void traversal(RenderKitBean renderKitBean,
055: FacesConfigBean facesConfigBean) {
056:
057: ComponentBean[] componentBeans = facesConfigBean
058: .getComponents();
059: try {
060: Element rootElement = cmDoc.createElement("taglib");
061: rootElement.setAttribute("uri",
062: "http://www.icesoft.com/icefaces/component");
063: cmDoc.appendChild(rootElement);
064: rootElement.appendChild(cmDoc.createTextNode("\n"));
065:
066: for (int i = 0; i < componentBeans.length; i++) {
067:
068: RendererBean rendererBean = renderKitBean.getRenderer(
069: componentBeans[i].getComponentFamily(),
070: componentBeans[i].getRendererType());
071: if (rendererBean == null) {
072: continue;
073: }
074:
075: String tagName = rendererBean.getTagName();
076: if (tagName == null || tagName.length() < 1) {
077: continue;
078: }
079:
080: Element tagElement = cmDoc.createElement("tag");
081: tagElement.appendChild(cmDoc.createTextNode("\n"));
082: tagElement.setAttribute("name", tagName);
083: rootElement.appendChild(tagElement);
084: rootElement.appendChild(cmDoc.createTextNode("\n"));
085:
086: baselineAttribute(componentBeans[i], tagElement,
087: facesConfigBean);
088: }
089: } catch (DOMException ex) {
090: ex.printStackTrace();
091: }
092: }
093:
094: private void baselineAttribute(ComponentBean componentBean,
095: Element tagElement, FacesConfigBean facesConfigBean) {
096:
097: PropertyBean[] propertyBeans = componentBean.getProperties();
098: for (int j = 0; j < propertyBeans.length; j++) {
099:
100: if (propertyBeans[j].isSuppressed()
101: || !propertyBeans[j].isTagAttribute()
102: || propertyBeans[j].getPropertyName().length() < 1
103: || propertyBeans[j].getCategory() == null
104: || propertyBeans[j].getCategory().length() < 1) {
105: continue;
106: }
107:
108: if (getElementByAttributeName(tagElement, "attribute",
109: propertyBeans[j].getPropertyName()) != null) {
110: continue;
111: }
112:
113: addCategory(tagElement, propertyBeans[j],
114: createAttributeElement(propertyBeans[j]));
115: }
116:
117: if (componentBean.getBaseComponentType() != null
118: && facesConfigBean.getComponent(componentBean
119: .getBaseComponentType()) != null) {
120: baselineAttribute(
121: facesConfigBean.getComponent(componentBean
122: .getBaseComponentType()), tagElement,
123: facesConfigBean);
124: }
125: }
126:
127: private Element createAttributeElement(PropertyBean propertyBean) {
128:
129: String suggestedValue = propertyBean.getSuggestedValue();
130: String defaultValue = propertyBean.getDefaultValue();
131: String propertyName = propertyBean.getPropertyName();
132: String propertyClass = propertyBean.getPropertyClass();
133: String category = propertyBean.getCategory();
134: String propertyEditor = propertyBean.getEditorClass();
135:
136: if (log.isLoggable(Level.FINEST)) {
137: log.log(Level.FINEST, " suggestedValue=" + suggestedValue
138: + " defaultValue=" + defaultValue
139: + " propertyName=" + propertyName
140: + " propertyClass=" + propertyClass + " category="
141: + category + " editor=" + propertyEditor);
142: }
143:
144: Element attributeElement = cmDoc.createElement("attribute");
145: attributeElement.setAttribute("name", propertyName);
146: attributeElement.setAttribute("displaylabel",
147: "%Attribute.Label." + propertyName);
148:
149: propertyDisplayLabelMap.put("Attribute.Label." + propertyName,
150: propertyBean.getPropertyName());
151: PropertyClassNameUtil util = new PropertyClassNameUtil();
152: String propertyTypeName = util.getMatchedName(propertyClass,
153: category, propertyName, propertyEditor);
154:
155: if (propertyTypeName != null && propertyTypeName.length() > 0) {
156: attributeElement.setAttribute("type", propertyTypeName);
157: }
158:
159: return attributeElement;
160: }
161:
162: private void addCategory(Element tagElement,
163: PropertyBean propertyBean, Element attributeElement) {
164:
165: Element categoryElement = null;
166: Node testElement = getElementByCategoryName(tagElement,
167: "category", propertyBean.getCategory());
168: if (testElement != null) {
169: return;
170: } else {
171: categoryElement = cmDoc.createElement("category");
172: categoryElement.setAttribute("displaylabel",
173: "%Category.Label." + propertyBean.getCategory());
174: categoryElement.setAttribute("name", propertyBean
175: .getCategory());
176: tagElement.appendChild(categoryElement);
177: tagElement.appendChild(cmDoc.createTextNode("\n"));
178:
179: //TODO: fix metadata related to category.
180: if (propertyBean != null
181: && propertyBean.getCategory() != null) {
182: propertyDisplayLabelMap.put("Category.Label."
183: + propertyBean.getCategory(), propertyBean
184: .getCategory());
185: }
186: }
187:
188: if (categoryElement != null) {
189: categoryElement.appendChild(attributeElement);
190: categoryElement.appendChild(cmDoc.createTextNode("\n"));
191: }
192: }
193:
194: public static void main(String[] args) {
195:
196: CMGenerator generator = new CMGenerator();
197: generator.generate(args);
198: }
199:
200: private void generate(String[] args) {
201:
202: //TODO:
203: //for(int i=0; i<args.length; i++){
204:
205: try {
206:
207: CMGenerator generator = new CMGenerator();
208: Document document = generator.initDoc();
209: generator.init();
210: generator.serialize(document);
211:
212: //TODO:
213: // CMParserHelper cmParser = new CMParserHelper();
214: // cmParser.getInfo();
215:
216: CMProperties printProperties = new CMProperties();
217: printProperties.putAll(generator.propertyDisplayLabelMap);
218:
219: File propFile = new File(generator.cmOutputFolder,
220: "ICEfaces_component_cm.properties");
221: generator.saveProperties(propFile.getPath(),
222: printProperties);
223: } catch (ParserConfigurationException ex) {
224: ex.printStackTrace();
225: } catch (TransformerConfigurationException ex) {
226: ex.printStackTrace();
227: } catch (TransformerException ex) {
228: ex.printStackTrace();
229: }
230: }
231:
232: private void saveProperties(String filePath, Properties properties) {
233:
234: File outputFile = new File(filePath);
235: try {
236: FileOutputStream outputStream = new FileOutputStream(
237: outputFile);
238: properties.store(outputStream, null);
239: } catch (FileNotFoundException ex) {
240: ex.printStackTrace();
241: } catch (IOException ex) {
242: ex.printStackTrace();
243: }
244: }
245:
246: private void setOutputFolder() {
247:
248: try {
249: //File folder = GeneratorUtil.getDestFolder("/home/frank/eclipse_ide/com.icesoft.ide.eclipse.designtime/metadata");
250: File folder = GeneratorUtil.getDestFolder(GeneratorUtil
251: .getWorkingFolder()
252: + "../generated-sources/eclipse/metadata");
253: cmOutputFolder = folder.getPath();
254: File outputFile = new File(folder,
255: "ICEfaces_component_cm.xml");
256: outputFile.mkdirs();
257: outputFile.delete();
258:
259: File propFile = new File(folder,
260: "ICEfaces_component_cm.properties");
261: propFile.delete();
262: } catch (FileNotFoundException ex) {
263: ex.printStackTrace();
264: }
265: }
266:
267: public void init() {
268:
269: setOutputFolder();
270: String fileName = "./src/main/resources/conf/extended-faces-config.xml";
271: String standard_html_renderkit = "jar:file:"
272: + GeneratorUtil.getWorkingFolder()
273: + "jsfmeta-resources.jar!/com/sun/faces/standard-html-renderkit.xml";
274: String standard_html_renderkit_overlay = "jar:file:"
275: + GeneratorUtil.getWorkingFolder()
276: + "jsfmeta-resources.jar!/com/sun/rave/jsfmeta/standard-html-renderkit-overlay.xml";
277: String standard_html_renderkit_fixup = "jar:file:"
278: + GeneratorUtil.getWorkingFolder()
279: + "jsfmeta-resources.jar!/META-INF/standard-html-renderkit-fixups.xml";
280:
281: String[] baseUrlList = new String[] { standard_html_renderkit,
282: standard_html_renderkit_overlay,
283: standard_html_renderkit_fixup };
284:
285: MetadataXmlParser metadataParser = new MetadataXmlParser();
286: metadataParser.setDesign(false);
287:
288: try {
289:
290: File file = new File(fileName);
291: FacesConfigBean facesConfigBean = metadataParser
292: .parse(file);
293: for (int i = 0; i < baseUrlList.length; i++) {
294: metadataParser.parse(new URL(baseUrlList[i]),
295: facesConfigBean);
296: }
297: RenderKitBean renderKitBean = facesConfigBean
298: .getRenderKit(RenderKitFactory.HTML_BASIC_RENDER_KIT);
299: traversal(renderKitBean, facesConfigBean);
300: } catch (IOException e) {
301: e.printStackTrace();
302: } catch (SAXException e) {
303: e.printStackTrace();
304: }
305: }
306:
307: /*
308: * @return category node by given child tag name
309: */
310: private Node getElementByCategoryName(Element tagElement,
311: String childTagName, String categoryName) {
312:
313: NodeList nodeList = tagElement
314: .getElementsByTagName(childTagName);
315: for (int i = 0; i < nodeList.getLength(); i++) {
316: Node node = nodeList.item(i);
317: NamedNodeMap namedNodeMap = node.getAttributes();
318: for (int j = 0; j < namedNodeMap.getLength(); j++) {
319: Node childNode = namedNodeMap.item(j);
320: if (childNode.getNodeValue().equalsIgnoreCase(
321: categoryName)) {
322: return node;
323: }
324: }
325: }
326: return null;
327:
328: }
329:
330: /*
331: * @return child node by given child value
332: */
333: private Node getElementByAttributeName(Element tagElement,
334: String childTagName, String value) {
335:
336: NodeList nodeList = tagElement
337: .getElementsByTagName(childTagName);
338: for (int i = 0; i < nodeList.getLength(); i++) {
339: Node node = nodeList.item(i);
340: NamedNodeMap namedNodeMap = node.getAttributes();
341: for (int j = 0; j < namedNodeMap.getLength(); j++) {
342: Node childNode = namedNodeMap.item(j);
343: if (childNode.getNodeValue().equalsIgnoreCase(value)) {
344: return childNode;
345: }
346: }
347: }
348: return null;
349: }
350:
351: private Node getChildNode(Node node, String namedValue) {
352:
353: NodeList nodeList = node.getChildNodes();
354: for (int i = 0; i < nodeList.getLength(); i++) {
355: Node child = nodeList.item(i);
356: if (child.getNodeName().equalsIgnoreCase(namedValue)) {
357: return child;
358: }
359: }
360: return null;
361: }
362:
363: public Document initDoc() throws ParserConfigurationException {
364: if (cmDoc == null) {
365: DocumentBuilder builder = DocumentBuilderFactory
366: .newInstance().newDocumentBuilder();
367: cmDoc = builder.newDocument();
368: }
369: return cmDoc;
370: }
371:
372: public void serialize(Document document)
373: throws TransformerConfigurationException,
374: TransformerException {
375: try {
376:
377: File outputXmlFile = new File(cmOutputFolder,
378: "ICEfaces_component_cm.xml");
379: TransformerFactory transformerFactory = TransformerFactory
380: .newInstance();
381: Transformer transformer = transformerFactory
382: .newTransformer();
383: transformer.transform(new DOMSource(document),
384: new StreamResult(new FileOutputStream(outputXmlFile
385: .getPath())));
386: } catch (TransformerConfigurationException ex) {
387: ex.printStackTrace();
388: } catch (TransformerException ex) {
389: ex.printStackTrace();
390: } catch (TransformerFactoryConfigurationError ex) {
391: ex.printStackTrace();
392: } catch (Exception ex) {
393: ex.printStackTrace();
394: }
395: }
396:
397: }
|