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   public 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       dis.close();
  91       LOG.info("***COUNTERS***");
  92       for (final Map.Entry<String, AtomicInteger> entry : counters.entrySet()) {
  93         LOG.info(entry.getKey() + ": " + entry.getValue());
  94       }
  95     }
  96   }
  97
  98   static final Pattern whitespace = Pattern.compile("\\s+");
  99   static String trim(final String s) {
 100     return whitespace.matcher(s).replaceAll(" ").trim();
 101   }
 102
 103   public void incrementCount(final String string) {
 104     AtomicInteger counter = counters.get(string);
 105     if (counter == null) {
 106       counter = new AtomicInteger();
 107       counters.put(string, counter);
 108     }
 109     counter.incrementAndGet();
 110   }
 111
 112
 113   // -------------------------------------------------------------------------
 114
 115   static class AppendAndIndexWikiCallback<T extends AbstractWiktionaryParser> implements WikiTokenizer.Callback {
 116
 117     final T parser;
 118     StringBuilder builder;
 119     IndexedEntry indexedEntry;
 120     IndexBuilder indexBuilder;
 121     final Map<String,FunctionCallback<T>> functionCallbacks = new LinkedHashMap<String, FunctionCallback<T>>();
 122
 123     boolean entryTypeNameSticks = false;
 124     EntryTypeName entryTypeName = null;
 125
 126     final Map<String,AtomicInteger> langCodeToTCount = new LinkedHashMap<String, AtomicInteger>();
 127
 128     final NameAndArgs<T> nameAndArgs = new NameAndArgs<T>();
 129
 130     public AppendAndIndexWikiCallback(final T parser) {
 131       this.parser = parser;
 132     }
 133
 134     public void reset(final StringBuilder builder, final IndexedEntry indexedEntry) {
 135       this.builder = builder;
 136       this.indexedEntry = indexedEntry;
 137       this.indexBuilder = null;
 138       entryTypeName = null;
 139       entryTypeNameSticks = false;
 140     }
 141
 142     public void dispatch(final String wikiText, final IndexBuilder indexBuilder, final EntryTypeName entryTypeName) {
 143       final IndexBuilder oldIndexBuilder = this.indexBuilder;
 144       final EntryTypeName oldEntryTypeName = this.entryTypeName;
 145       this.indexBuilder = indexBuilder;
 146       if (!entryTypeNameSticks) {
 147         this.entryTypeName = EnumUtil.min(entryTypeName, this.entryTypeName);
 148       }
 149       if (entryTypeName == null) this.entryTypeName = null;
 150       WikiTokenizer.dispatch(wikiText, false, this);
 151       this.indexBuilder = oldIndexBuilder;
 152       this.entryTypeName = oldEntryTypeName;
 153     }
 154
 155     public String dispatch(final String wikiText, final EntryTypeName entryTypeName) {
 156       final int start = builder.length();
 157       dispatch(wikiText, this.indexBuilder, entryTypeName);
 158       return builder.substring(start);
 159     }
 160
 161     @Override
 162     public void onPlainText(final String plainText) {
 163       // The only non-recursive callback.  Just appends to the builder, and indexes.
 164       builder.append(plainText);
 165       if (indexBuilder != null && entryTypeName != null && indexedEntry != null) {
 166         indexBuilder.addEntryWithString(indexedEntry, plainText, entryTypeName);
 167       }
 168     }
 169
 170     @Override
 171     public void onWikiLink(WikiTokenizer wikiTokenizer) {
 172       final String text = wikiTokenizer.wikiLinkText();
 173       @SuppressWarnings("unused")
 174       final String link = wikiTokenizer.wikiLinkDest();
 175       dispatch(text, entryTypeName);
 176     }
 177
 178     @Override
 179     public void onFunction(
 180         final WikiTokenizer wikiTokenizer,
 181         final String name,
 182         final List<String> args,
 183         final Map<String, String> namedArgs) {
 184
 185       FunctionCallback<T> functionCallback = functionCallbacks.get(name);
 186       if (functionCallback == null || !functionCallback.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, this)) {
 187         // Default function handling:
 188         parser.removeUselessArgs(namedArgs);
 189         final boolean single = args.isEmpty() && namedArgs.isEmpty();
 190         builder.append(single ? "{" : "{{");
 191
 192         final IndexBuilder oldIndexBuilder = indexBuilder;
 193         indexBuilder = null;
 194         nameAndArgs.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, this);
 195         indexBuilder = oldIndexBuilder;
 196
 197         builder.append(single ? "}" : "}}");
 198       }
 199     }
 200
 201     @Override
 202     public void onHtml(WikiTokenizer wikiTokenizer) {
 203       // Unindexed for now.
 204       builder.append(wikiTokenizer.token());
 205     }
 206
 207     @Override
 208     public void onMarkup(WikiTokenizer wikiTokenizer) {
 209       // Do nothing.
 210     }
 211
 212     @Override
 213     public final void onComment(WikiTokenizer wikiTokenizer) {
 214       // Do nothing.
 215     }
 216
 217     @Override
 218     public void onNewline(WikiTokenizer wikiTokenizer) {
 219       assert false;
 220     }
 221
 222     @Override
 223     public void onHeading(WikiTokenizer wikiTokenizer) {
 224       assert false;
 225     }
 226
 227     @Override
 228     public void onListItem(WikiTokenizer wikiTokenizer) {
 229       assert false;
 230     }
 231   }
 232
 233   // --------------------------------------------------------------------
 234
 235   static final class NameAndArgs<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 236     @Override
 237     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 238         final Map<String, String> namedArgs, final T parser,
 239         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 240
 241       if (name != null) {
 242         appendAndIndexWikiCallback.dispatch(name, null);
 243       }
 244       for (int i = 0; i < args.size(); ++i) {
 245         if (args.get(i).length() > 0) {
 246           appendAndIndexWikiCallback.builder.append("|");
 247           appendAndIndexWikiCallback.dispatch(args.get(i), null, null);
 248         }
 249       }
 250       appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 251       return true;
 252     }
 253   }
 254   static NameAndArgs<AbstractWiktionaryParser> NAME_AND_ARGS = new NameAndArgs<AbstractWiktionaryParser>();
 255
 256   static void appendNamedArgs(final Map<String, String> namedArgs,
 257       final AppendAndIndexWikiCallback<?> appendAndIndexWikiCallback) {
 258     for (final Map.Entry<String, String> entry : namedArgs.entrySet()) {
 259       appendAndIndexWikiCallback.builder.append("|");
 260       appendAndIndexWikiCallback.dispatch(entry.getKey(), null, null);
 261       appendAndIndexWikiCallback.builder.append("=");
 262       EntryTypeName entryTypeName = null;
 263       IndexBuilder indexBuilder = null;
 264       // This doesn't work: we'd need to add to word-forms.
 265 //      System.out.println(entry.getKey());
 266 //      if (entry.getKey().equals("tr")) {
 267 //        entryTypeName = EntryTypeName.WIKTIONARY_TRANSLITERATION;
 268 //        indexBuilder = appendAndIndexWikiCallback.parser.foreignIndexBuilder;
 269 //      }
 270       appendAndIndexWikiCallback.dispatch(entry.getValue(), indexBuilder, entryTypeName);
 271     }
 272   }
 273
 274 }