/**
* Copyright (c) 2013 Puppet Labs, Inc. and other contributors, as listed below.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Puppet Labs
*/
package com.puppetlabs.geppetto.pp.dsl.contentassist;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import org.apache.commons.codec.language.DoubleMetaphone;
import org.apache.commons.lang.StringUtils;
import com.puppetlabs.geppetto.common.score.ScoreKeeper;
import com.puppetlabs.geppetto.common.score.ScoreKeeper.ScoreEntry;
import com.puppetlabs.geppetto.pp.PPPackage;
import com.puppetlabs.geppetto.pp.dsl.PPDSLConstants;
import com.puppetlabs.geppetto.pp.dsl.linking.PPSearchPath;
import com.puppetlabs.geppetto.pp.pptp.PPTPPackage;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.xtext.naming.IQualifiedNameConverter;
import org.eclipse.xtext.naming.QualifiedName;
import org.eclipse.xtext.resource.IEObjectDescription;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.inject.Inject;
/**
* Generator of proposals
*
*/
public class PPProposalsGenerator {
/**
* compares the pronunciation difference between given reference and candidates
*
*/
public static class PronunciationComparator implements Comparator<String> {
private DoubleMetaphone encoder;
private String metaphoneName;
PronunciationComparator(DoubleMetaphone encoder, String metaphoneReference) {
this.encoder = encoder;
this.metaphoneName = metaphoneReference;
}
@Override
public int compare(String a, String b) {
String am = encoder.encode(a);
String bm = encoder.encode(b);
int al = StringUtils.getLevenshteinDistance(metaphoneName, am);
int bl = StringUtils.getLevenshteinDistance(metaphoneName, bm);
if(al == bl)
return 0;
return al < bl
? -1
: 1;
}
}
/**
* PP FQN to/from Xtext QualifiedName converter.
*/
@Inject
IQualifiedNameConverter converter;
protected final static EClass[] DEF_AND_TYPE_ARGUMENTS = {
PPPackage.Literals.DEFINITION_ARGUMENT, PPTPPackage.Literals.TYPE_ARGUMENT };
protected final static EClass[] DEF_AND_TYPE = { PPTPPackage.Literals.TYPE, PPPackage.Literals.DEFINITION };
/**
* Computes attribute proposals where the class/definition name must match exactly, but where
* parameters are processed with fuzzy logic.
*
* @param currentName
* @param descs
* @param searchPath
* TODO
* @param types
* @return
*/
public String[] computeAttributeProposals(final QualifiedName currentName, Collection<IEObjectDescription> descs,
PPSearchPath searchPath) {
if(currentName.getSegmentCount() < 2)
return new String[0];
final DoubleMetaphone encoder = new DoubleMetaphone();
final String metaphoneName = encoder.encode(currentName.getLastSegment());
Collection<String> proposals = generateAttributeCandidates(currentName, descs, searchPath);
// propose all, but sort them based on likeness
String[] result = new String[proposals.size()];
proposals.toArray(result);
Arrays.sort(result, new PronunciationComparator(encoder, metaphoneName));
return result;
}
public String[] computeDistinctProposals(String currentName, List<IEObjectDescription> descs) {
return computeDistinctProposals(currentName, descs, false);
}
/**
* Attempts to produce a list of more distinct names than the given name by making
* name absolute.
*
* @param currentName
* the name for which proposals are wanted
* @param descs
* index of descriptors
*/
public String[] computeDistinctProposals(String currentName, List<IEObjectDescription> descs,
boolean upperCaseProposals) {
List<String> proposals = Lists.newArrayList();
if(currentName.startsWith("::"))
return new String[0]; // can not make a global name more specific than what it already is
for(IEObjectDescription d : descs) {
String s = converter.toString(d.getQualifiedName());
if(!s.startsWith("::")) {
String s2 = "::" + s;
if(!(s2.equals(currentName) || proposals.contains(s2)))
proposals.add(s2);
}
if(s.equals(currentName) || proposals.contains(s))
continue;
proposals.add(s);
}
String[] props = proposals.toArray(new String[proposals.size()]);
Arrays.sort(props);
return upperCaseProposals
? toUpperCaseProposals(props)
: props;
}
/**
* Attempts to produce a list of names that are close to the given name. At most 5 proposals
* are generated. The returned proposals are made in order of "pronunciation distance" which is
* obtained by taking the Levenshtein distance between the Double Monophone encodings of
* candidate and given name. Candidates are selected as the names with shortest Levenshtein distance
* and names that are Monophonically equal, or starts or ends monophonically.
*
* @param currentName
* the name for which proposals are to be generated
* @param descs
* the descriptors of available named values
* @param searchPath
* TODO
* @param types
* if stated, the wanted types of named values
* @return
* array of proposals, possibly empty, but never null.
*/
public String[] computeProposals(final String currentName, Collection<IEObjectDescription> descs,
boolean upperCaseProposals, PPSearchPath searchPath, EClass... types) {
if(currentName == null || currentName.length() < 1)
return new String[0];
// compute the 5 best matches and only accept if score <= 5
ScoreKeeper<IEObjectDescription> tracker = new ScoreKeeper<IEObjectDescription>(5, false, 5);
// List<IEObjectDescription> metaphoneAlike = Lists.newArrayList();
final DoubleMetaphone encoder = new DoubleMetaphone();
final String metaphoneName = encoder.encode(currentName);
for(IEObjectDescription d : descs) {
EClass c = d.getEClass();
typeok: if(types != null && types.length > 0) {
for(EClass wanted : types)
if((wanted == c || wanted.isSuperTypeOf(c)))
break typeok;
continue;
}
// filter based on path visibility
if(searchPath.searchIndexOf(d) == -1)
continue; // not visible according to path
String candidateName = converter.toString(d.getName());
tracker.addScore(StringUtils.getLevenshteinDistance(currentName, candidateName), d);
String candidateMetaphone = encoder.encode(candidateName);
// metaphone matches are scored on the pronounciation distance
if(metaphoneName.equals(candidateMetaphone) //
||
candidateMetaphone.startsWith(metaphoneName) //
|| candidateMetaphone.endsWith(metaphoneName) //
)
tracker.addScore(StringUtils.getLevenshteinDistance(metaphoneName, candidateMetaphone), d);
// System.err.printf("Metaphone alike: %s == %s\n", currentName, candidateName);
}
List<String> result = Lists.newArrayList();
// System.err.print("Scores = ");
for(ScoreEntry<IEObjectDescription> entry : tracker.getScoreEntries()) {
String s = converter.toString(entry.getData().getName());
result.add(s);
// System.err.printf("%d %s, ", entry.getScore(), s);
}
// System.err.println();
String[] proposals = result.toArray(new String[result.size()]);
PronunciationComparator x = new PronunciationComparator(encoder, metaphoneName);
Arrays.sort(proposals, x);
// System.err.print("Order = ");
// for(int i = 0; i < proposals.length; i++)
// System.err.printf("%s, ", proposals[i]);
// System.err.println();
return upperCaseProposals
? toUpperCaseProposals(proposals)
: proposals;
}
public String[] computeProposals(final String currentName, Collection<IEObjectDescription> descs,
PPSearchPath searchPath, EClass... types) {
return computeProposals(currentName, descs, false, searchPath, types);
}
public Collection<String> generateAttributeCandidates(final QualifiedName currentName,
Collection<IEObjectDescription> descs, PPSearchPath searchPath) {
// find candidate names
if(currentName.getSegmentCount() < 2)
return Collections.emptySet();
// unique set of proposed attribute names (last segment)
Set<String> proposed = Sets.newHashSet();
List<QualifiedName> classesToSearch = Lists.newArrayList();
Set<QualifiedName> visited = Sets.newHashSet();
classesToSearch.add(currentName.skipLast(1));
while(classesToSearch.size() > 0) {
QualifiedName prefix = classesToSearch.remove(0);
if(visited.contains(prefix))
continue;
visited.add(prefix); // prevent recursion
// find all that start with className and are properties or parameters
// also find the class/definition itself (possibly ambiguous).
for(IEObjectDescription d : descs) {
if(searchPath.searchIndexOf(d) == -1)
continue; // not visible
EClass ec = d.getEClass();
QualifiedName name = d.getName();
if(name.startsWith(prefix)) {
if(name.getSegmentCount() == prefix.getSegmentCount()) {
// exact match, check if this is the correct type
if(DEF_AND_TYPE[0].isSuperTypeOf(ec) || DEF_AND_TYPE[1].isSuperTypeOf(ec)) {
String parentName = d.getUserData(PPDSLConstants.PARENT_NAME_DATA);
if(parentName != null && parentName.length() > 0)
classesToSearch.add(converter.toQualifiedName(parentName));
}
continue; // exact match can not be an argument
}
if(DEF_AND_TYPE_ARGUMENTS[0].isSuperTypeOf(ec) || DEF_AND_TYPE_ARGUMENTS[1].isSuperTypeOf(ec))
proposed.add(d.getName().getLastSegment());
}
}
}
return proposed;
}
private String toInitialUpperCase(String s) {
if(s == null || s.length() < 1)
return s;
char c = s.charAt(0);
if(Character.isUpperCase(c))
return s;
return Character.toString(c).toUpperCase() + s.substring(1);
}
private String toUpperCaseProposal(String original) {
QualifiedName fqn = converter.toQualifiedName(original);
String[] segments = new String[fqn.getSegmentCount()];
for(int i = 0; i < fqn.getSegmentCount(); i++)
segments[i] = toInitialUpperCase(fqn.getSegment(i));
return converter.toString(QualifiedName.create(segments));
}
private String[] toUpperCaseProposals(String[] original) {
for(int i = 0; i < original.length; i++) {
original[i] = toUpperCaseProposal(original[i]);
}
return original;
};
}