src/com/hughes/android/dictionary/engine/WiktionarySplitter.java

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 package com.hughes.android.dictionary.engine;
  16
  17 import java.io.BufferedOutputStream;
  18 import java.io.DataOutputStream;
  19 import java.io.File;
  20 import java.io.FileOutputStream;
  21 import java.io.IOException;
  22 import java.util.ArrayList;
  23 import java.util.LinkedHashMap;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.regex.Matcher;
  27 import java.util.regex.Pattern;
  28
  29 import javax.xml.parsers.ParserConfigurationException;
  30 import javax.xml.parsers.SAXParser;
  31
  32 import org.apache.xerces.jaxp.SAXParserFactoryImpl;
  33 import org.xml.sax.Attributes;
  34 import org.xml.sax.SAXException;
  35
  36 import com.hughes.android.dictionary.parser.wiktionary.WiktionaryLangs;
  37
  38 public class WiktionarySplitter extends org.xml.sax.helpers.DefaultHandler {
  39
  40   // The matches the whole line, otherwise regexes don't work well on French:
  41   // {{=uk=}}
  42   // Spanish has no initial headings, tried to also detect {{ES as such
  43   // with "^(\\{\\{ES|(=+)[^=]).*$" but that broke English.
  44   static final Pattern headingStart = Pattern.compile("^(=+)[^=].*$", Pattern.MULTILINE);
  45
  46   final Map<String,List<Selector>> pathToSelectors = new LinkedHashMap<String, List<Selector>>();
  47   List<Selector> currentSelectors = null;
  48
  49   StringBuilder titleBuilder;
  50   StringBuilder textBuilder;
  51   StringBuilder currentBuilder = null;
  52
  53   public static void main(final String[] args) throws Exception {
  54     final WiktionarySplitter wiktionarySplitter = new WiktionarySplitter();
  55     wiktionarySplitter.go();
  56   }
  57
  58   private WiktionarySplitter() {
  59     List<Selector> selectors;
  60     for (final String code : WiktionaryLangs.wikiCodeToIsoCodeToWikiName.keySet()) {
  61       //if (!code.equals("fr")) {continue;}
  62       selectors = new ArrayList<WiktionarySplitter.Selector>();
  63       pathToSelectors.put(String.format("data/inputs/%swiktionary-pages-articles.xml", code), selectors);
  64       for (final Map.Entry<String, String> entry : WiktionaryLangs.wikiCodeToIsoCodeToWikiName.get(code).entrySet()) {
  65         final String dir = String.format("data/inputs/wikiSplit/%s", code);
  66         new File(dir).mkdirs();
  67         selectors.add(new Selector(String.format("%s/%s.data", dir, entry.getKey()), entry.getValue()));
  68       }
  69     }
  70   }
  71
  72   private void go() throws Exception {
  73     final SAXParser parser = SAXParserFactoryImpl.newInstance().newSAXParser();
  74
  75     // Configure things.
  76     for (final Map.Entry<String, List<Selector>> pathToSelectorsEntry : pathToSelectors.entrySet()) {
  77
  78       currentSelectors = pathToSelectorsEntry.getValue();
  79
  80       for (final Selector selector : currentSelectors) {
  81         selector.out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(selector.outFilename)));
  82       }
  83
  84       // Do it.
  85       try {
  86         parser.parse(new File(pathToSelectorsEntry.getKey()), this);
  87       } catch (Exception e) {
  88         System.err.println("Exception during parse, lastPageTitle=" + lastPageTitle + ", titleBuilder=" + titleBuilder.toString());
  89         throw e;
  90       }
  91
  92       // Shutdown.
  93       for (final Selector selector : currentSelectors) {
  94         selector.out.close();
  95       }
  96
  97     }
  98   }
  99
 100   String lastPageTitle = null;
 101   int pageCount = 0;
 102   private void endPage() {
 103     final String title = titleBuilder.toString();
 104     lastPageTitle = title;
 105     if (++pageCount % 1000 == 0) {
 106       System.out.println("endPage: " + title + ", count=" + pageCount);
 107     }
 108     if (title.startsWith("Wiktionary:") ||
 109             title.startsWith("Appendix:") ||
 110             title.startsWith("Help:") ||
 111             title.startsWith("Index:") ||
 112             title.startsWith("MediaWiki:") ||
 113             title.startsWith("Citations:") ||
 114             title.startsWith("Concordance:") ||
 115             title.startsWith("Glossary:") ||
 116             title.startsWith("Rhymes:") ||
 117             title.startsWith("Category:") ||
 118             title.startsWith("Wikisaurus:") ||
 119             title.startsWith("Unsupported titles/") ||
 120             title.startsWith("Transwiki:") ||
 121             title.startsWith("File:") ||
 122             title.startsWith("Thread:") ||
 123             title.startsWith("Template:") ||
 124             title.startsWith("Summary:") ||
 125             // DE
 126             title.startsWith("Datei:") ||
 127             title.startsWith("Verzeichnis:") ||
 128             title.startsWith("Vorlage:") ||
 129             title.startsWith("Thesaurus:") ||
 130             title.startsWith("Kategorie:") ||
 131             title.startsWith("Hilfe:") ||
 132             // FR:
 133             title.startsWith("Annexe:") ||
 134             title.startsWith("Catégori:") ||
 135             title.startsWith("Modèle:") ||
 136             title.startsWith("Thésaurus:") ||
 137             title.startsWith("Projet:") ||
 138             title.startsWith("Aide:") ||
 139             title.startsWith("Fichier:") ||
 140             title.startsWith("Wiktionnaire:") ||
 141             title.startsWith("Catégorie:") ||
 142             title.startsWith("Portail:") ||
 143             title.startsWith("utiliusateur:") ||
 144             title.startsWith("Kategorio:") ||
 145             // IT
 146             title.startsWith("Wikizionario:") ||
 147             title.startsWith("Appendice:") ||
 148             title.startsWith("Categoria:") ||
 149             title.startsWith("Aiuto:") ||
 150             title.startsWith("Portail:") ||
 151             // ES
 152             title.startsWith("Apéndice:") ||
 153             title.startsWith("Archivo:") ||
 154             title.startsWith("Ayuda:") ||
 155             title.startsWith("Categoría:") ||
 156             title.startsWith("Plantilla:") ||
 157             title.startsWith("Wikcionario:") ||
 158
 159             // sentinel
 160             false
 161             ) {
 162         return;
 163     }
 164     if (title.contains(":")) {
 165         if (!title.startsWith("Sign gloss:")) {
 166             System.err.println("title with colon: " + title);
 167         }
 168     }
 169
 170     String text = textBuilder.toString();
 171
 172     while (text.length() > 0) {
 173       // Find start.
 174       final Matcher startMatcher = headingStart.matcher(text);
 175       if (!startMatcher.find()) {
 176         return;
 177       }
 178       text = text.substring(startMatcher.end());
 179
 180       final String heading = startMatcher.group();
 181       for (final Selector selector : currentSelectors) {
 182         if (selector.pattern.matcher(heading).find()) {
 183
 184           // Find end.
 185           final int depth = startMatcher.group(1).length();
 186           final Pattern endPattern = Pattern.compile(String.format("^={1,%d}[^=].*$", depth), Pattern.MULTILINE);
 187
 188           final Matcher endMatcher = endPattern.matcher(text);
 189           final int end;
 190           if (endMatcher.find()) {
 191             end = endMatcher.start();
 192           } else {
 193             end = text.length();
 194           }
 195
 196           final String sectionText = text.substring(0, end);
 197           final Section section = new Section(title, heading, sectionText);
 198
 199           try {
 200             selector.out.writeUTF(section.title);
 201             selector.out.writeUTF(section.heading);
 202             final byte[] bytes = section.text.getBytes("UTF8");
 203             selector.out.writeInt(bytes.length);
 204             selector.out.write(bytes);
 205           } catch (IOException e) {
 206             throw new RuntimeException(e);
 207           }
 208
 209           text = text.substring(end);
 210         }
 211       }
 212     }
 213
 214   }
 215
 216   // -----------------------------------------------------------------------
 217
 218   static class Section implements java.io.Serializable {
 219     private static final long serialVersionUID = -7676549898325856822L;
 220
 221     final String title;
 222     final String heading;
 223     final String text;
 224
 225     public Section(final String title, final String heading, final String text) {
 226       this.title = title;
 227       this.heading = heading;
 228       this.text = text;
 229
 230       //System.out.printf("TITLE:%s\nHEADING:%s\nTEXT:%s\n\n\n\n\n\n", title, heading, text);
 231     }
 232   }
 233
 234   static class Selector {
 235     final String outFilename;
 236     final Pattern pattern;
 237
 238     DataOutputStream out;
 239
 240     public Selector(final String filename, final String pattern) {
 241       this.outFilename = filename;
 242       this.pattern = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
 243     }
 244   }
 245
 246   // -----------------------------------------------------------------------
 247
 248     @Override
 249     public void startElement(String uri, String localName, String qName,
 250         Attributes attributes) {
 251       currentBuilder = null;
 252       if ("page".equals(qName)) {
 253         titleBuilder = new StringBuilder();
 254
 255         // Start with "\n" to better match certain strings.
 256         textBuilder = new StringBuilder("\n");
 257       } else if ("title".equals(qName)) {
 258         currentBuilder = titleBuilder;
 259       } else if ("text".equals(qName)) {
 260         currentBuilder = textBuilder;
 261       }
 262     }
 263
 264     @Override
 265     public void characters(char[] ch, int start, int length) throws SAXException {
 266       if (currentBuilder != null) {
 267         currentBuilder.append(ch, start, length);
 268       }
 269     }
 270
 271     @Override
 272     public void endElement(String uri, String localName, String qName)
 273         throws SAXException {
 274       currentBuilder = null;
 275       if ("page".equals(qName)) {
 276         endPage();
 277       }
 278     }
 279
 280     public void parse(final File file) throws ParserConfigurationException,
 281         SAXException, IOException {
 282       final SAXParser parser = SAXParserFactoryImpl.newInstance().newSAXParser();
 283       parser.parse(file, this);
 284     }
 285
 286 }