CommentParser.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2019 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.dossier.issue.parser;
 
import java.util.Collections;
import java.util.List;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.turro.string.Strings;
import org.turro.elephant.context.Application;
 
public class CommentParser {
  
  private final StringJoiner changes, comment, participants, attachments, relations,
          endBlock, upload, description, priority, type, grouping, dossier,
          version, publishable, control, delivery, startDate, status,
          resolution, duplicated, hours, expenses, price, prevision;
  private final String text, proppart, attachpart;
 
  public CommentParser(String text) {
    this.text = text;
    changes = toRegExp(Application.getAllLocales("Changes"));
    comment = toRegExp(Application.getAllLocales("Comment"));
    participants = toRegExp(Application.getAllLocales("Participants"));
    attachments = toRegExp(Application.getAllLocales("Attachments"));
    relations = toRegExp(Application.getAllLocales("Relations"));
    endBlock = new StringJoiner("|");
    endBlock.merge(changes)
            .merge(comment)
            .merge(participants)
            .merge(attachments)
            .merge(relations);
    upload = toRegExp(Application.getAllLocales("Upload"));
    description = toRegExp(Application.getAllLocales("Description"));
    priority = toRegExp(Application.getAllLocales("Priority"));
    type = toRegExp(Application.getAllLocales("Type"));
    grouping = toRegExp(Application.getAllLocales("Grouping"));
    dossier = toRegExp(Application.getAllLocales("Dossier"));
    version = toRegExp(Application.getAllLocales("Version"));
    publishable = toRegExp(Application.getAllLocales("Publishable"));
    control = toRegExp(Application.getAllLocales("Control"));
    delivery = toRegExp(Application.getAllLocales("Delivery"));
    startDate = toRegExp(Application.getAllLocales("Start date"));
    status = toRegExp(Application.getAllLocales("Status"));
    resolution = toRegExp(Application.getAllLocales("Resolution"));
    duplicated = toRegExp(Application.getAllLocales("Duplicated"));
    hours = toRegExp(Application.getAllLocales("Hours"));
    expenses = toRegExp(Application.getAllLocales("Expenses"));
    price = toRegExp(Application.getAllLocales("Price"));
    prevision = toRegExp(Application.getAllLocales("Prevision"));
    proppart = getText(changes);
    attachpart = getText(attachments);
  }
 
  public String getComment() {
    return getText(comment);
  }
  
  public List<PairValue> getParticipants() {
    String block = getText(participants);
    if(!Strings.isBlank(block)) {
      return Pattern.compile("\\R*(.+)\\s*:\\s*(.+)(\\R|$)")
                    .matcher(block)
                    .results()
                    .map((m) -> new PairValue(m.group(1), m.group(2)))
                    .collect(Collectors.toList());
    }
    return Collections.EMPTY_LIST;
  }
  
  public List<String> getAttachments() {
    return Strings.isBlank(attachpart) ? null : Pattern.compile("\\R(" + upload + ")\\s*\\[\\s*(.+)\\](\\R|$)")
                  .matcher(attachpart)
                  .results()
                  .map((m) -> m.group(2))
                  .collect(Collectors.toList());
  }
  
  public PairValue getDescription() {
    return getPairValue(description);
  }
 
  public PairValue getPriority() {
    return getPairValue(priority);
  }
  
  public PairValue getType() {
    return getPairValue(type);
  }
 
  public PairValue getGrouping() {
    return getPairValue(grouping);
  }
 
  public PairValue getDossier() {
    return getPairValue(dossier);
  }
  
  public PairValue getVersion() {
    return getPairValue(version);
  }
 
  public PairValue getPublishable() {
    return getPairValue(publishable);
  }
 
  public PairValue getControl() {
    return getPairValue(control);
  }
  
  public PairValue getDelivery() {
    return getPairValue(delivery);
  }
 
  public PairValue getStartDate() {
    return getPairValue(startDate);
  }
 
  public PairValue getStatus() {
    return getPairValue(status);
  }
 
  public PairValue getResolution() {
    return getPairValue(resolution);
  }
 
  public PairValue getDuplicated() {
    return getPairValue(duplicated);
  }
 
  public String getHours() {
    return getSingleValue(hours);
  }
 
  public String getExpenses() {
    return getSingleValue(expenses);
  }
 
  public String getPrice() {
    return getSingleValue(price);
  }
 
  public PairValue getPrevisionHours() {
    return getPairValue(prevision, hours, "/");
  }
 
  public PairValue getPrevisionExpenses() {
    return getPairValue(prevision, expenses, "/");
  }
 
  public PairValue getPrevisionPrice() {
    return getPairValue(prevision, price, "/");
  }
 
  public String getText(StringJoiner block) {
    int idxStart = 0, idxEnd;
    Pattern pstart = Pattern.compile("(\\R|^)(" + block + ")\\R");
    Matcher mstart = pstart.matcher(text);
    if(mstart.find()) {
      idxStart = mstart.end() - 1;
    }
    if(idxStart > 0) {
      Pattern pend = Pattern.compile("\\R((" + endBlock + ")\\R|$)");
      Matcher mend = pend.matcher(text);
      if(mend.find(idxStart + 1)) {
        idxEnd = mend.start();
      } else {
        idxEnd = text.length();
      }
      if(idxEnd > idxStart) {
        return text.substring(idxStart, idxEnd);
      }
    }
    return null;
  }
  
  public String getSingleValue(StringJoiner options) {
    if(!Strings.isBlank(proppart)) {
      Pattern pattern = Pattern.compile("\\R(" + options + ")\\s*:\\s*(.+)(\\R|$)");
      Matcher matcher = pattern.matcher(proppart);
      if(matcher.find()) {
        return matcher.group(2);
      }
    }
    return null;
  }
  
  public PairValue getPairValue(StringJoiner options) {
    if(!Strings.isBlank(proppart)) {
      Pattern pattern = Pattern.compile("\\R(" + options + ")\\s*\\[\\s*(.*)\\s*\\]:\\h*(.*)(\\R|$)");
      Matcher matcher = pattern.matcher(proppart);
      if(matcher.find()) {
        return new PairValue(matcher.group(2), matcher.group(3));
      }
    }
    return null;
  }
  
  public PairValue getPairValue(StringJoiner prefix, StringJoiner options, String separator) {
    if(!Strings.isBlank(proppart)) {
      Pattern pattern = Pattern.compile("\\R((" + prefix + ")" + separator + "(" + options + "))\\s*\\[\\s*(.*)\\s*\\]:\\h*(.*)(\\R|$)");
      Matcher matcher = pattern.matcher(proppart);
      if(matcher.find()) {
        return new PairValue(matcher.group(4), matcher.group(5));
      }
    }
    return null;
  }
  
  private StringJoiner toRegExp(List<String> opts) {
    StringJoiner sj = new StringJoiner("|");
    opts.forEach((opt) -> {
      sj.add(opt);
    });
    return sj;
  }
  
}