File size: 12,448 Bytes
6312f15 |
1 |
/* * The contents of this file are subject to the Mozilla Public 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 * https://www.mozilla.org/en-US/MPL/ * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the * License for the specific language governing rights and limitations * under the License. * * The Original Code is "Simplenlg". * * The Initial Developer of the Original Code is Ehud Reiter, Albert Gatt and Dave Westwater. * Portions created by Ehud Reiter, Albert Gatt and Dave Westwater are Copyright (C) 2010-11 The University of Aberdeen. All Rights Reserved. * * Contributor(s): Ehud Reiter, Albert Gatt, Dave Westwater, Roman Kutlak, Margaret Mitchell, and Saad Mahamood. */package simplenlg.lexicon;import java.io.File;import java.net.URI;import java.net.URISyntaxException;import java.net.URL;import java.util.*;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.Node;import org.w3c.dom.NodeList;import simplenlg.features.Inflection;import simplenlg.features.LexicalFeature;import simplenlg.framework.ElementCategory;import simplenlg.framework.LexicalCategory;import simplenlg.framework.WordElement;/** * This class loads words from an XML lexicon. All features specified in the * lexicon are loaded * * @author ereiter */public class XMLLexicon extends Lexicon { // node names in lexicon XML files private static final String XML_BASE = "base"; // base form of Word private static final String XML_CATEGORY = "category"; // base form of Word private static final String XML_ID = "id"; // base form of Word private static final String XML_WORD = "word"; // node defining a word // lexicon private Set<WordElement> words; // set of words private Map<String, WordElement> indexByID; // map from ID to word private Map<String, List<WordElement>> indexByBase; // map from base to set // of words with this // baseform private Map<String, List<WordElement>> indexByVariant; // map from variants // to set of words // with this variant /**********************************************************************/ // constructors /**********************************************************************/ /** * Load an XML Lexicon from a named file. * * @param filename -- The String file path to the {@link XMLLexicon} file. */ public XMLLexicon(String filename) { super(); File file = new File(filename); createLexicon(file.toURI()); } /** * Load an XML Lexicon from a File. * * @param file -- The {@link File} object to the {@link XMLLexicon} file. */ public XMLLexicon(File file) { super(); createLexicon(file.toURI()); } /** * Load an XML Lexicon from a URI * * @param lexiconURI -- The lexicon {@link URI} to the {@link XMLLexicon} file. */ public XMLLexicon(URI lexiconURI) { super(); createLexicon(lexiconURI); } public XMLLexicon() { try { URL defaultLexicon = this.getClass().getClassLoader().getResource("default-lexicon.xml"); if(null != defaultLexicon) { createLexicon(defaultLexicon.toURI()); } else { createLexicon(this.getClass().getResource("/simplenlg/lexicon/default-lexicon.xml").toURI()); } } catch(URISyntaxException ex) { System.out.println(ex.toString()); } } /** * method to actually load and index the lexicon from a URI */ private void createLexicon(URI lexiconURI) { // initialise objects words = new HashSet<WordElement>(); indexByID = new HashMap<String, WordElement>(); indexByBase = new HashMap<String, List<WordElement>>(); indexByVariant = new HashMap<String, List<WordElement>>(); try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); // BUG: CWE-611: Improper Restriction of XML External Entity Reference// DocumentBuilder builder = factory.newDocumentBuilder();// FIXED: Document doc = builder.parse(lexiconURI.toString()); if(doc != null) { Element lexRoot = doc.getDocumentElement(); NodeList wordNodes = lexRoot.getChildNodes(); for(int i = 0; i < wordNodes.getLength(); i++) { Node wordNode = wordNodes.item(i); // ignore things that aren't elements if(wordNode.getNodeType() == Node.ELEMENT_NODE) { WordElement word = convertNodeToWord(wordNode); if(word != null) { words.add(word); IndexWord(word); } } } } } catch(Exception ex) { System.out.println(ex.toString()); } addSpecialCases(); } /** * add special cases to lexicon */ private void addSpecialCases() { // add variants of "be" WordElement be = getWord("be", LexicalCategory.VERB); if(be != null) { updateIndex(be, "is", indexByVariant); updateIndex(be, "am", indexByVariant); updateIndex(be, "are", indexByVariant); updateIndex(be, "was", indexByVariant); updateIndex(be, "were", indexByVariant); } } /** * create a simplenlg WordElement from a Word node in a lexicon XML file */ private WordElement convertNodeToWord(Node wordNode) { // if this isn't a Word node, ignore it if(!wordNode.getNodeName().equalsIgnoreCase(XML_WORD)) return null; // // if there is no base, flag an error and return null // String base = XPathUtil.extractValue(wordNode, Constants.XML_BASE); // if (base == null) { // System.out.println("Error in loading XML lexicon: Word with no base"); // return null; // } // create word WordElement word = new WordElement(); List<Inflection> inflections = new ArrayList<Inflection>(); // now copy features NodeList nodes = wordNode.getChildNodes(); for(int i = 0; i < nodes.getLength(); i++) { Node featureNode = nodes.item(i); if(featureNode.getNodeType() == Node.ELEMENT_NODE) { String feature = featureNode.getNodeName().trim(); String value = featureNode.getTextContent(); if(value != null) value = value.trim(); if(feature == null) { System.err.println("Error in XML lexicon node for " + word.toString()); break; } if(feature.equalsIgnoreCase(XML_BASE)) { word.setBaseForm(value); } else if(feature.equalsIgnoreCase(XML_CATEGORY)) word.setCategory(LexicalCategory.valueOf(value.toUpperCase())); else if(feature.equalsIgnoreCase(XML_ID)) word.setId(value); else if(value == null || value.equals("")) { // if this is an infl code, add it to inflections Inflection infl = Inflection.getInflCode(feature); if(infl != null) { inflections.add(infl); } else { // otherwise assume it's a boolean feature word.setFeature(feature, true); } } else word.setFeature(feature, value); } } // if no infl specified, assume regular if(inflections.isEmpty()) { inflections.add(Inflection.REGULAR); } // default inflection code is "reg" if we have it, else random pick form // infl codes available Inflection defaultInfl = inflections.contains(Inflection.REGULAR) ? Inflection.REGULAR : inflections.get(0); word.setFeature(LexicalFeature.DEFAULT_INFL, defaultInfl); word.setDefaultInflectionalVariant(defaultInfl); for(Inflection infl : inflections) { word.addInflectionalVariant(infl); } // done, return word return word; } /** * add word to internal indices */ private void IndexWord(WordElement word) { // first index by base form String base = word.getBaseForm(); // shouldn't really need is, as all words have base forms if(base != null) { updateIndex(word, base, indexByBase); } // now index by ID, which should be unique (if present) String id = word.getId(); if(id != null) { if(indexByID.containsKey(id)) System.out.println("Lexicon error: ID " + id + " occurs more than once"); indexByID.put(id, word); } // now index by variant for(String variant : getVariants(word)) { updateIndex(word, variant, indexByVariant); } // done } /** * convenience method to update an index */ private void updateIndex(WordElement word, String base, Map<String, List<WordElement>> index) { if(!index.containsKey(base)) index.put(base, new ArrayList<WordElement>()); index.get(base).add(word); } /******************************************************************************************/ // main methods to get data from lexicon /******************************************************************************************/ /* * (non-Javadoc) * * @see simplenlg.lexicon.Lexicon#getWords(java.lang.String, * simplenlg.features.LexicalCategory) */ @Override public List<WordElement> getWords(String baseForm, LexicalCategory category) { return getWordsFromIndex(baseForm, category, indexByBase); } /** * get matching keys from an index map */ private List<WordElement> getWordsFromIndex(String indexKey, LexicalCategory category, Map<String, List<WordElement>> indexMap) { List<WordElement> result = new ArrayList<WordElement>(); // case 1: unknown, return empty list if(!indexMap.containsKey(indexKey)) { return result; } // case 2: category is ANY, return everything if(category == LexicalCategory.ANY) { for(WordElement word : indexMap.get(indexKey)) { result.add(new WordElement(word)); } return result; } else { // case 3: other category, search for match for(WordElement word : indexMap.get(indexKey)) { if(word.getCategory() == category) { result.add(new WordElement(word)); } } } return result; } /* * (non-Javadoc) * * @see simplenlg.lexicon.Lexicon#getWordsByID(java.lang.String) */ @Override public List<WordElement> getWordsByID(String id) { List<WordElement> result = new ArrayList<WordElement>(); if(indexByID.containsKey(id)) { result.add(new WordElement(indexByID.get(id))); } return result; } /* * (non-Javadoc) * * @see simplenlg.lexicon.Lexicon#getWordsFromVariant(java.lang.String, * simplenlg.features.LexicalCategory) */ @Override public List<WordElement> getWordsFromVariant(String variant, LexicalCategory category) { return getWordsFromIndex(variant, category, indexByVariant); } /** * quick-and-dirty routine for getting morph variants should be replaced by * something better! */ private Set<String> getVariants(WordElement word) { Set<String> variants = new HashSet<String>(); variants.add(word.getBaseForm()); ElementCategory category = word.getCategory(); if(category instanceof LexicalCategory) { switch((LexicalCategory) category){ case NOUN: variants.add(getVariant(word, LexicalFeature.PLURAL, "s")); break; case ADJECTIVE: variants.add(getVariant(word, LexicalFeature.COMPARATIVE, "er")); variants.add(getVariant(word, LexicalFeature.SUPERLATIVE, "est")); break; case VERB: variants.add(getVariant(word, LexicalFeature.PRESENT3S, "s")); variants.add(getVariant(word, LexicalFeature.PAST, "ed")); variants.add(getVariant(word, LexicalFeature.PAST_PARTICIPLE, "ed")); variants.add(getVariant(word, LexicalFeature.PRESENT_PARTICIPLE, "ing")); break; default: // only base needed for other forms break; } } return variants; } /** * quick-and-dirty routine for computing morph forms Should be replaced by * something better! */ private String getVariant(WordElement word, String feature, String suffix) { if(word.hasFeature(feature)) return word.getFeatureAsString(feature); else return getForm(word.getBaseForm(), suffix); } /** * quick-and-dirty routine for standard orthographic changes Should be * replaced by something better! */ private String getForm(String base, String suffix) { // add a suffix to a base form, with orthographic changes // rule 1 - convert final "y" to "ie" if suffix does not start with "i" // eg, cry + s = cries , not crys if(base.endsWith("y") && !suffix.startsWith("i")) base = base.substring(0, base.length() - 1) + "ie"; // rule 2 - drop final "e" if suffix starts with "e" or "i" // eg, like+ed = liked, not likeed if(base.endsWith("e") && (suffix.startsWith("e") || suffix.startsWith("i"))) base = base.substring(0, base.length() - 1); // rule 3 - insert "e" if suffix is "s" and base ends in s, x, z, ch, sh // eg, watch+s -> watches, not watchs if(suffix.startsWith("s") && (base.endsWith("s") || base.endsWith("x") || base.endsWith("z") || base.endsWith( "ch") || base.endsWith("sh"))) base = base + "e"; // have made changes, now append and return return base + suffix; // eg, want + s = wants }} |