src/com/hughes/android/dictionary/parser/wiktionary/AbstractWiktionaryParser.java

   1 // Copyright 2012 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.parser.wiktionary;
  16
  17 import java.io.BufferedInputStream;
  18 import java.io.DataInputStream;
  19 import java.io.EOFException;
  20 import java.io.File;
  21 import java.io.FileInputStream;
  22 import java.io.IOException;
  23 import java.util.LinkedHashMap;
  24 import java.util.LinkedHashSet;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import java.util.SortedMap;
  29 import java.util.TreeMap;
  30 import java.util.concurrent.atomic.AtomicInteger;
  31 import java.util.logging.Level;
  32 import java.util.logging.Logger;
  33 import java.util.regex.Pattern;
  34
  35 import com.hughes.android.dictionary.engine.EntrySource;
  36 import com.hughes.android.dictionary.engine.EntryTypeName;
  37 import com.hughes.android.dictionary.engine.IndexBuilder;
  38 import com.hughes.android.dictionary.engine.IndexedEntry;
  39 import com.hughes.android.dictionary.parser.Parser;
  40 import com.hughes.android.dictionary.parser.WikiTokenizer;
  41 import com.hughes.util.EnumUtil;
  42
  43 public abstract class AbstractWiktionaryParser implements Parser {
  44
  45   static final Logger LOG = Logger.getLogger("WiktionaryParser");
  46
  47   final SortedMap<String, AtomicInteger> counters = new TreeMap<String, AtomicInteger>();
  48   final Set<String> pairsAdded = new LinkedHashSet<String>();
  49
  50   EntrySource entrySource;
  51   String title;
  52
  53
  54   abstract void parseSection(final String heading, final String text);
  55
  56   abstract void removeUselessArgs(final Map<String, String> namedArgs);
  57
  58   @Override
  59   public void parse(final File file, final EntrySource entrySource, final int pageLimit) throws IOException {
  60     this.entrySource = entrySource;
  61     int pageCount = 0;
  62     final DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
  63     try {
  64     while (true) {
  65       if (pageLimit >= 0 && pageCount >= pageLimit) {
  66         return;
  67       }
  68
  69       try {
  70         title = dis.readUTF();
  71       } catch (EOFException e) {
  72         LOG.log(Level.INFO, "EOF reading split.");
  73         dis.close();
  74         return;
  75       }
  76       final String heading = dis.readUTF();
  77       final int bytesLength = dis.readInt();
  78       final byte[] bytes = new byte[bytesLength];
  79       dis.readFully(bytes);
  80       final String text = new String(bytes, "UTF8");
  81
  82       parseSection(heading, text);
  83
  84       ++pageCount;
  85       if (pageCount % 1000 == 0) {
  86         LOG.info("pageCount=" + pageCount);
  87       }
  88     }
  89     } finally {
  90       LOG.info("***COUNTERS***");
  91       for (final Map.Entry<String, AtomicInteger> entry : counters.entrySet()) {
  92         LOG.info(entry.getKey() + ": " + entry.getValue());
  93       }
  94     }
  95   }
  96
  97   static final Pattern whitespace = Pattern.compile("\\s+");
  98   static String trim(final String s) {
  99     return whitespace.matcher(s).replaceAll(" ").trim();
 100   }
 101
 102   public void incrementCount(final String string) {
 103     AtomicInteger counter = counters.get(string);
 104     if (counter == null) {
 105       counter = new AtomicInteger();
 106       counters.put(string, counter);
 107     }
 108     counter.incrementAndGet();
 109   }
 110
 111
 112   // -------------------------------------------------------------------------
 113
 114   static class AppendAndIndexWikiCallback<T extends AbstractWiktionaryParser> implements WikiTokenizer.Callback {
 115
 116     final T parser;
 117     StringBuilder builder;
 118     IndexedEntry indexedEntry;
 119     IndexBuilder indexBuilder;
 120     final Map<String,FunctionCallback<T>> functionCallbacks = new LinkedHashMap<String, FunctionCallback<T>>();
 121
 122     boolean entryTypeNameSticks = false;
 123     EntryTypeName entryTypeName = null;
 124
 125     final Map<String,AtomicInteger> langCodeToTCount = new LinkedHashMap<String, AtomicInteger>();
 126
 127     final NameAndArgs<T> nameAndArgs = new NameAndArgs<T>();
 128
 129     public AppendAndIndexWikiCallback(final T parser) {
 130       this.parser = parser;
 131     }
 132
 133     public void reset(final StringBuilder builder, final IndexedEntry indexedEntry) {
 134       this.builder = builder;
 135       this.indexedEntry = indexedEntry;
 136       this.indexBuilder = null;
 137       entryTypeName = null;
 138       entryTypeNameSticks = false;
 139     }
 140
 141     public void dispatch(final String wikiText, final IndexBuilder indexBuilder, final EntryTypeName entryTypeName) {
 142       final IndexBuilder oldIndexBuilder = this.indexBuilder;
 143       final EntryTypeName oldEntryTypeName = this.entryTypeName;
 144       this.indexBuilder = indexBuilder;
 145       if (!entryTypeNameSticks) {
 146         this.entryTypeName = EnumUtil.min(entryTypeName, this.entryTypeName);
 147       }
 148       if (entryTypeName == null) this.entryTypeName = null;
 149       WikiTokenizer.dispatch(wikiText, false, this);
 150       this.indexBuilder = oldIndexBuilder;
 151       this.entryTypeName = oldEntryTypeName;
 152     }
 153
 154     public String dispatch(final String wikiText, final EntryTypeName entryTypeName) {
 155       final int start = builder.length();
 156       dispatch(wikiText, this.indexBuilder, entryTypeName);
 157       return builder.substring(start);
 158     }
 159
 160     @Override
 161     public void onPlainText(final String plainText) {
 162       // The only non-recursive callback.  Just appends to the builder, and indexes.
 163       builder.append(plainText);
 164       if (indexBuilder != null && entryTypeName != null && indexedEntry != null) {
 165         indexBuilder.addEntryWithString(indexedEntry, plainText, entryTypeName);
 166       }
 167     }
 168
 169     @Override
 170     public void onWikiLink(WikiTokenizer wikiTokenizer) {
 171       final String text = wikiTokenizer.wikiLinkText();
 172       @SuppressWarnings("unused")
 173       final String link = wikiTokenizer.wikiLinkDest();
 174       dispatch(text, entryTypeName);
 175     }
 176
 177     @Override
 178     public void onFunction(
 179         final WikiTokenizer wikiTokenizer,
 180         final String name,
 181         final List<String> args,
 182         final Map<String, String> namedArgs) {
 183
 184       FunctionCallback<T> functionCallback = functionCallbacks.get(name);
 185       if (functionCallback == null || !functionCallback.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, this)) {
 186         // Default function handling:
 187         parser.removeUselessArgs(namedArgs);
 188         final boolean single = args.isEmpty() && namedArgs.isEmpty();
 189         builder.append(single ? "{" : "{{");
 190
 191         final IndexBuilder oldIndexBuilder = indexBuilder;
 192         indexBuilder = null;
 193         nameAndArgs.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, this);
 194         indexBuilder = oldIndexBuilder;
 195
 196         builder.append(single ? "}" : "}}");
 197       }
 198     }
 199
 200     @Override
 201     public void onHtml(WikiTokenizer wikiTokenizer) {
 202       // Unindexed for now.
 203       builder.append(wikiTokenizer.token());
 204     }
 205
 206     @Override
 207     public void onMarkup(WikiTokenizer wikiTokenizer) {
 208       // Do nothing.
 209     }
 210
 211     @Override
 212     public final void onComment(WikiTokenizer wikiTokenizer) {
 213       // Do nothing.
 214     }
 215
 216     @Override
 217     public final void onNewline(WikiTokenizer wikiTokenizer) {
 218       assert false;
 219     }
 220
 221     @Override
 222     public final void onHeading(WikiTokenizer wikiTokenizer) {
 223       assert false;
 224     }
 225
 226     @Override
 227     public final void onListItem(WikiTokenizer wikiTokenizer) {
 228       assert false;
 229     }
 230   }
 231
 232   // --------------------------------------------------------------------
 233
 234   static final class NameAndArgs<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 235     @Override
 236     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 237         final Map<String, String> namedArgs, final T parser,
 238         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 239
 240       if (name != null) {
 241         appendAndIndexWikiCallback.builder.append(name);
 242       }
 243       for (int i = 0; i < args.size(); ++i) {
 244         if (args.get(i).length() > 0) {
 245           appendAndIndexWikiCallback.builder.append("|");
 246           appendAndIndexWikiCallback.dispatch(args.get(i), null, null);
 247         }
 248       }
 249       appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 250       return true;
 251     }
 252   }
 253   static NameAndArgs<AbstractWiktionaryParser> NAME_AND_ARGS = new NameAndArgs<AbstractWiktionaryParser>();
 254
 255   static void appendNamedArgs(final Map<String, String> namedArgs,
 256       final AppendAndIndexWikiCallback<?> appendAndIndexWikiCallback) {
 257     for (final Map.Entry<String, String> entry : namedArgs.entrySet()) {
 258       appendAndIndexWikiCallback.builder.append("|");
 259       appendAndIndexWikiCallback.dispatch(entry.getKey(), null, null);
 260       appendAndIndexWikiCallback.builder.append("=");
 261       EntryTypeName entryTypeName = null;
 262       IndexBuilder indexBuilder = null;
 263       // This doesn't work: we'd need to add to word-forms.
 264 //      System.out.println(entry.getKey());
 265 //      if (entry.getKey().equals("tr")) {
 266 //        entryTypeName = EntryTypeName.WIKTIONARY_TRANSLITERATION;
 267 //        indexBuilder = appendAndIndexWikiCallback.parser.foreignIndexBuilder;
 268 //      }
 269       appendAndIndexWikiCallback.dispatch(entry.getValue(), indexBuilder, entryTypeName);
 270     }
 271   }
 272
 273 }