AutomaticFixing.java

/*
 *  WPCleaner: A tool to help on Wikipedia maintenance tasks.
 *  Copyright (C) 2013  Nicolas Vervelle
 *
 *  See README.txt file for licensing information.
 */

package org.wikipediacleaner.api.data;

import java.util.Collection;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;


/**
 * Utility class to memorize automatic fixing parameters
 */
public class AutomaticFixing implements Comparable<AutomaticFixing> {

  /**
   * Original text.
   */
  private String originalText;

  /**
   * Replacement text.
   */
  private String replacementText;

  /**
   * Regular expression or not.
   */
  private boolean regex;

  /**
   * Default constructor.
   */
  public AutomaticFixing() {
    //
  }

  /**
   * Constructor.
   * 
   * @param from Original text.
   * @param to Replacement text.
   * @param regex Regular expression or not.
   */
  public AutomaticFixing(String from, String to, boolean regex) {
    originalText = from;
    replacementText = to;
    this.regex = regex;
  }

  /**
   * @return Original text.
   */
  public String getOriginalText() {
    return originalText;
  }

  /**
   * @param text Original text.
   */
  public void setOriginalText(String text) {
    originalText = text;
  }

  /**
   * @return Replacement text.
   */
  public String getReplacementText() {
    return replacementText;
  }

  /**
   * @param text Replacement text.
   */
  public void setReplacementText(String text) {
    replacementText = text;
  }

  /**
   * @return Regular expression or not.
   */
  public Boolean getRegex() {
    return Boolean.valueOf(regex);
  }

  /**
   * @param flag Regular expression or not.
   */
  public void setRegex(Boolean flag) {
    regex = Boolean.TRUE.equals(flag);
  }

  /**
   * Apply a list of automatic fixing expressions to a text.
   * 
   * @param fixing List of automatic fixing expressions.
   * @param text Original text.
   * @param replacements Optional list of replacements performed.
   * @return Text with replacements done.
   */
  public static String apply(
      Collection<AutomaticFixing> fixing, String text,
      List<String> replacements) {
    if ((text == null) || (fixing == null) || (fixing.isEmpty())) {
      return text;
    }

    // Apply each automatic fixing expression to the text
    StringBuffer tmpText = new StringBuffer();
    for (AutomaticFixing replacement : fixing) {

      // Initialize data
      tmpText.setLength(0);
      String originalText = replacement.getOriginalText();
      String replacementText = replacement.getReplacementText();
      if (replacementText == null) {
        replacementText = "";
      }

      int currentIndex = 0;
      if (replacement.regex) {
        // Apply for a regular expression
        try {
          Pattern pattern = Pattern.compile(originalText);
          Matcher matcher = pattern.matcher(text);
          while (matcher.find()) {
            String foundText = matcher.group();
            int start = matcher.start();
            int end = matcher.end();
            int currentLength = tmpText.length();
            matcher.appendReplacement(tmpText, replacementText);
            if (replacements != null) {
              String replacedBy = tmpText.substring(currentLength + start - currentIndex);
              String comment = foundText + " → " + replacedBy;
              if (!replacements.contains(comment)) {
                replacements.add(comment);
              }
            }
            currentIndex = end;
          }
        } catch (PatternSyntaxException e) {
          System.err.println("Error with " + originalText + ": " + e.getMessage());
        }
      } else {
        // Apply for a basic expression
        boolean finished = false;
        while (!finished) {
          int newIndex = text.indexOf(originalText, currentIndex);
          if (newIndex < 0) {
            finished = true;
          } else {
            if (newIndex > currentIndex) {
              tmpText.append(text.substring(currentIndex, newIndex));
              currentIndex = newIndex;
            }
            tmpText.append(replacementText);
            currentIndex += originalText.length();
            if (replacements != null) {
              String comment = originalText + " → " + replacementText;
              if (!replacements.contains(comment)) {
                replacements.add(comment);
              }
            }
          }
        }
      }
      if (currentIndex > 0) {
        if (currentIndex < text.length()) {
          tmpText.append(text.substring(currentIndex));
        }
        text = tmpText.toString();
      }
    }

    return text;
  }

  /**
   * @param af Other automatic fixing expression.
   * @return Comparison of the two automatic fixing expressions.
   * @see java.lang.Comparable#compareTo(java.lang.Object)
   */
  @Override
  public int compareTo(AutomaticFixing af) {
    if (af == null) {
      return -1;
    }
    int compare = originalText.compareTo(af.getOriginalText());
    if (compare != 0) {
      return compare;
    }
    return replacementText.compareTo(af.getReplacementText());
  }

  /**
   * @return String representation of the automatic fixing expression.
   * @see java.lang.Object#toString()
   */
  @Override
  public String toString() {
    return originalText + " → " + replacementText;
  }
}