/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.directory.studio.ldapbrowser.common.filtereditor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.apache.directory.api.ldap.model.constants.SchemaConstants;
import org.apache.directory.api.ldap.model.schema.AttributeType;
import org.apache.directory.api.ldap.model.schema.MatchingRule;
import org.apache.directory.api.ldap.model.schema.ObjectClass;
import org.apache.directory.studio.ldapbrowser.common.BrowserCommonActivator;
import org.apache.directory.studio.ldapbrowser.common.BrowserCommonConstants;
import org.apache.directory.studio.ldapbrowser.core.model.filter.LdapFilter;
import org.apache.directory.studio.ldapbrowser.core.model.filter.LdapFilterExtensibleComponent;
import org.apache.directory.studio.ldapbrowser.core.model.filter.LdapFilterItemComponent;
import org.apache.directory.studio.ldapbrowser.core.model.filter.parser.LdapFilterParser;
import org.apache.directory.studio.ldapbrowser.core.model.filter.parser.LdapFilterToken;
import org.apache.directory.studio.ldapbrowser.core.model.schema.Schema;
import org.apache.directory.studio.ldapbrowser.core.model.schema.SchemaUtils;
import org.eclipse.jface.fieldassist.IContentProposal;
import org.eclipse.jface.fieldassist.IContentProposalProvider;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.contentassist.CompletionProposal;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jface.text.contentassist.IContextInformationValidator;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateCompletionProcessor;
import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.swt.graphics.Image;
/**
* The FilterContentAssistProcessor computes the content proposals for the filter editor.
*
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
*/
public class FilterContentAssistProcessor extends TemplateCompletionProcessor implements IContentAssistProcessor,
IContentProposalProvider
{
private static final Comparator<String> NAME_AND_OID_COMPARATOR = new Comparator<String>()
{
public int compare( String s1, String s2 )
{
if ( s1.matches( "[0-9\\.]+" ) && !s2.matches( "[0-9\\.]+" ) ) //$NON-NLS-1$ //$NON-NLS-2$
{
return 1;
}
else if ( !s1.matches( "[0-9\\.]+" ) && s2.matches( "[0-9\\.]+" ) ) //$NON-NLS-1$ //$NON-NLS-2$
{
return -1;
}
else
{
return s1.compareToIgnoreCase( s2 );
}
}
};
/** The parser. */
private LdapFilterParser parser;
/** The source viewer, may be null. */
private ISourceViewer sourceViewer;
/** The auto activation characters. */
private char[] autoActivationCharacters;
/** The schema, used to retrieve attributeType and objectClass information. */
private Schema schema;
/** The possible attribute types. */
private Map<String, AttributeType> possibleAttributeTypes;
/** The possible filter types. */
private Map<String, String> possibleFilterTypes;
/** The possible object classes. */
private Map<String, ObjectClass> possibleObjectClasses;
/** The possible matching rules. */
private Map<String, MatchingRule> possibleMatchingRules;
/**
* Creates a new instance of FilterContentAssistProcessor.
*
* @param parser the parser
*/
public FilterContentAssistProcessor( LdapFilterParser parser )
{
this( null, parser );
}
/**
* Creates a new instance of FilterContentAssistProcessor.
*
* @param sourceViewer the source viewer
* @param parser the parser
*/
public FilterContentAssistProcessor( ISourceViewer sourceViewer, LdapFilterParser parser )
{
this.parser = parser;
this.sourceViewer = sourceViewer;
this.autoActivationCharacters = new char[7 + 10 + 26 + 26];
this.autoActivationCharacters[0] = '(';
this.autoActivationCharacters[1] = ')';
this.autoActivationCharacters[2] = '&';
this.autoActivationCharacters[3] = '|';
this.autoActivationCharacters[4] = '!';
this.autoActivationCharacters[5] = ':';
this.autoActivationCharacters[6] = '.';
int i = 7;
for ( char c = 'a'; c <= 'z'; c++, i++ )
{
this.autoActivationCharacters[i] = c;
}
for ( char c = 'A'; c <= 'Z'; c++, i++ )
{
this.autoActivationCharacters[i] = c;
}
for ( char c = '0'; c <= '9'; c++, i++ )
{
this.autoActivationCharacters[i] = c;
}
}
/**
* Sets the schema, used to retrieve attributeType and objectClass information.
*
* @param schema the schema
*/
public void setSchema( Schema schema )
{
this.schema = schema;
possibleAttributeTypes = new TreeMap<String, AttributeType>( NAME_AND_OID_COMPARATOR );
possibleFilterTypes = new LinkedHashMap<String, String>();
possibleObjectClasses = new TreeMap<String, ObjectClass>( NAME_AND_OID_COMPARATOR );
possibleMatchingRules = new TreeMap<String, MatchingRule>( NAME_AND_OID_COMPARATOR );
if ( schema != null )
{
Collection<AttributeType> attributeTypeDescriptions = schema.getAttributeTypeDescriptions();
for ( AttributeType atd : attributeTypeDescriptions )
{
possibleAttributeTypes.put( atd.getOid(), atd );
for ( String atdName : atd.getNames() )
{
possibleAttributeTypes.put( atdName, atd );
}
}
possibleFilterTypes.put( "=", Messages.getString( "FilterContentAssistProcessor.Equals" ) ); //$NON-NLS-1$ //$NON-NLS-2$
possibleFilterTypes.put( "=*", Messages.getString( "FilterContentAssistProcessor.Present" ) ); //$NON-NLS-1$ //$NON-NLS-2$
possibleFilterTypes.put( "<=", Messages.getString( "FilterContentAssistProcessor.LessThanOrEquals" ) ); //$NON-NLS-1$ //$NON-NLS-2$
possibleFilterTypes.put( ">=", Messages.getString( "FilterContentAssistProcessor.GreaterThanOrEquals" ) ); //$NON-NLS-1$ //$NON-NLS-2$
possibleFilterTypes.put( "~=", Messages.getString( "FilterContentAssistProcessor.Approximately" ) ); //$NON-NLS-1$ //$NON-NLS-2$
Collection<ObjectClass> ocds = schema.getObjectClassDescriptions();
for ( ObjectClass ocd : ocds )
{
possibleObjectClasses.put( ocd.getOid(), ocd );
for ( String name : ocd.getNames() )
{
possibleObjectClasses.put( name, ocd );
}
}
Collection<MatchingRule> matchingRuleDescriptions = schema.getMatchingRuleDescriptions();
for ( MatchingRule description : matchingRuleDescriptions )
{
possibleMatchingRules.put( description.getOid(), description );
for ( String name : description.getNames() )
{
possibleMatchingRules.put( name, description );
}
}
}
}
/**
* @see org.eclipse.jface.text.templates.TemplateCompletionProcessor#getCompletionProposalAutoActivationCharacters()
*/
public char[] getCompletionProposalAutoActivationCharacters()
{
return autoActivationCharacters;
}
/**
* @see org.eclipse.jface.text.templates.TemplateCompletionProcessor#computeCompletionProposals(org.eclipse.jface.text.ITextViewer, int)
*/
public ICompletionProposal[] computeCompletionProposals( ITextViewer viewer, int offset )
{
return computeCompletionProposals( offset );
}
/**
* @see org.eclipse.jface.fieldassist.IContentProposalProvider#getProposals(java.lang.String, int)
*/
public IContentProposal[] getProposals( final String contents, final int position )
{
parser.parse( contents );
ICompletionProposal[] oldProposals = computeCompletionProposals( position );
IContentProposal[] proposals = new IContentProposal[oldProposals.length];
for ( int i = 0; i < oldProposals.length; i++ )
{
final ICompletionProposal oldProposal = oldProposals[i];
final Document document = new Document( contents );
oldProposal.apply( document );
proposals[i] = new IContentProposal()
{
public String getContent()
{
return document.get();
}
public int getCursorPosition()
{
return oldProposal.getSelection( document ).x;
}
public String getDescription()
{
return oldProposal.getAdditionalProposalInfo();
}
public String getLabel()
{
return oldProposal.getDisplayString();
}
public String toString()
{
return getContent();
}
};
}
return proposals;
}
/**
* Computes completion proposals.
*
* @param offset the offset
*
* @return the matching completion proposals
*/
private ICompletionProposal[] computeCompletionProposals( int offset )
{
String[] possibleObjectClasses = schema == null ? new String[0] : SchemaUtils.getNamesAsArray( schema
.getObjectClassDescriptions() );
Arrays.sort( possibleObjectClasses );
List<ICompletionProposal> proposalList = new ArrayList<ICompletionProposal>();
LdapFilter filter = parser.getModel().getFilter( offset );
if ( filter != null && offset > 0 )
{
// case 0: open curly started, show templates and all attribute types
if ( filter.getStartToken() != null && filter.getFilterComponent() == null )
{
if ( sourceViewer != null )
{
ICompletionProposal[] templateProposals = super.computeCompletionProposals( sourceViewer, offset );
if ( templateProposals != null )
{
proposalList.addAll( Arrays.asList( templateProposals ) );
}
}
addPossibleAttributeTypes( proposalList, "", offset ); //$NON-NLS-1$
}
// case A: simple filter
if ( filter.getFilterComponent() instanceof LdapFilterItemComponent )
{
LdapFilterItemComponent fc = ( LdapFilterItemComponent ) filter.getFilterComponent();
// case A1: editing attribute type: show matching attribute types
if ( fc.getStartToken().getOffset() <= offset
&& offset <= fc.getStartToken().getOffset() + fc.getStartToken().getLength() )
{
addPossibleAttributeTypes( proposalList, fc.getAttributeToken().getValue(), fc.getAttributeToken()
.getOffset() );
}
String attributeType = null;
if ( schema != null && schema.hasAttributeTypeDescription( fc.getAttributeToken().getValue() ) )
{
attributeType = fc.getAttributeToken().getValue();
}
// case A2: after attribte type: show possible filter types and extensible match options
if ( attributeType != null )
{
if ( ( fc.getAttributeToken().getOffset() <= offset || fc.getFilterToken() != null )
&& offset <= fc.getAttributeToken().getOffset() + fc.getAttributeToken().getLength()
+ ( fc.getFilterToken() != null ? fc.getFilterToken().getLength() : 0 ) )
{
//String attributeType = fc.getAttributeToken().getValue();
String filterType = fc.getFilterToken() != null ? fc.getFilterToken().getValue() : ""; //$NON-NLS-1$
int filterTypeOffset = fc.getAttributeToken().getOffset() + fc.getAttributeToken().getLength();
addPossibleFilterTypes( proposalList, attributeType, filterType, filterTypeOffset );
}
}
// case A3: editing objectClass attribute: show matching object classes
if ( attributeType != null && SchemaConstants.OBJECT_CLASS_AT.equalsIgnoreCase( attributeType ) )
{
if ( ( fc.getValueToken() != null && fc.getValueToken().getOffset() <= offset || fc
.getFilterToken() != null )
&& offset <= fc.getAttributeToken().getOffset() + fc.getAttributeToken().getLength()
+ ( fc.getFilterToken() != null ? fc.getFilterToken().getLength() : 0 )
+ ( fc.getValueToken() != null ? fc.getValueToken().getLength() : 0 ) )
{
addPossibleObjectClasses( proposalList, fc.getValueToken() == null ? "" : fc.getValueToken() //$NON-NLS-1$
.getValue(), fc.getValueToken() == null ? offset : fc.getValueToken().getOffset() );
}
}
}
// case B: extensible filter
if ( filter.getFilterComponent() instanceof LdapFilterExtensibleComponent )
{
LdapFilterExtensibleComponent fc = ( LdapFilterExtensibleComponent ) filter.getFilterComponent();
// case B1: editing extensible attribute type: show matching attribute types
if ( fc.getAttributeToken() != null && fc.getAttributeToken().getOffset() <= offset
&& offset <= fc.getAttributeToken().getOffset() + fc.getAttributeToken().getLength() )
{
addPossibleAttributeTypes( proposalList, fc.getAttributeToken().getValue(), fc.getAttributeToken()
.getOffset() );
}
// case B2: editing dn
if ( fc.getDnAttrToken() != null && fc.getDnAttrToken().getOffset() <= offset
&& offset <= fc.getDnAttrToken().getOffset() + fc.getDnAttrToken().getLength() )
{
addDnAttr( proposalList, fc.getDnAttrToken().getValue(), fc.getDnAttrToken().getOffset() );
}
// case B3: editing matching rule
if ( fc.getMatchingRuleColonToken() != null
&& fc.getMatchingRuleToken() == null
&& fc.getMatchingRuleColonToken().getOffset() <= offset
&& offset <= fc.getMatchingRuleColonToken().getOffset()
+ fc.getMatchingRuleColonToken().getLength() )
{
if ( fc.getDnAttrColonToken() == null )
{
addDnAttr( proposalList, "", offset ); //$NON-NLS-1$
}
addPossibleMatchingRules( proposalList, "", offset, fc.getEqualsColonToken(), fc.getEqualsToken() ); //$NON-NLS-1$
}
if ( fc.getMatchingRuleToken() != null && fc.getMatchingRuleToken().getOffset() <= offset
&& offset <= fc.getMatchingRuleToken().getOffset() + fc.getMatchingRuleToken().getLength() )
{
if ( fc.getDnAttrColonToken() == null )
{
addDnAttr( proposalList, fc.getMatchingRuleToken().getValue(), fc.getMatchingRuleToken()
.getOffset() );
}
String matchingRuleValue = fc.getMatchingRuleToken().getValue();
addPossibleMatchingRules( proposalList, matchingRuleValue, fc.getMatchingRuleToken().getOffset(),
fc.getEqualsColonToken(), fc.getEqualsToken() );
}
}
}
return proposalList.toArray( new ICompletionProposal[0] );
}
/**
* Adds the possible attribute types to the proposal list.
*
* @param proposalList the proposal list
* @param attributeType the current attribute type
* @param offset the offset
*/
private void addPossibleAttributeTypes( List<ICompletionProposal> proposalList, String attributeType, int offset )
{
if ( schema != null )
{
for ( String possibleAttributeType : possibleAttributeTypes.keySet() )
{
AttributeType description = possibleAttributeTypes.get( possibleAttributeType );
if ( possibleAttributeType.toUpperCase().startsWith( attributeType.toUpperCase() ) )
{
String replacementString = possibleAttributeType;
String displayString = possibleAttributeType;
if ( displayString.equals( description.getOid() ) )
{
displayString += " (" + SchemaUtils.toString( description ) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
else
{
displayString += " (" + description.getOid() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
String info = SchemaUtils.getLdifLine( description );
ICompletionProposal proposal = new CompletionProposal( replacementString, offset, attributeType
.length(), replacementString.length(), getAttributeTypeImage(), displayString, null, info );
proposalList.add( proposal );
}
}
}
}
/**
* Adds the possible attribute types to the proposal list.
*
* @param proposalList the proposal list
* @param attributeType the current attribute type
* @param offset the offset
*/
private void addPossibleFilterTypes( List<ICompletionProposal> proposalList, String attributeType,
String filterType, int offset )
{
if ( schema != null )
{
Map<String, String> copy = new LinkedHashMap<String, String>( possibleFilterTypes );
if ( SchemaUtils.getEqualityMatchingRuleNameOrNumericOidTransitive( schema
.getAttributeTypeDescription( attributeType ), schema ) == null )
{
copy.remove( "=" ); //$NON-NLS-1$
copy.remove( "~=" ); //$NON-NLS-1$
}
if ( SchemaUtils.getOrderingMatchingRuleNameOrNumericOidTransitive( schema
.getAttributeTypeDescription( attributeType ), schema ) == null )
{
copy.remove( "<=" ); //$NON-NLS-1$
copy.remove( ">=" ); //$NON-NLS-1$
}
for ( String possibleFilterType : copy.keySet() )
{
String replacementString = possibleFilterType;
String displayString = copy.get( possibleFilterType );
ICompletionProposal proposal = new CompletionProposal( replacementString, offset, filterType.length(),
possibleFilterType.length(), getFilterTypeImage(), displayString, null, null );
proposalList.add( proposal );
}
}
}
/**
* Adds the possible object classes to the proposal list.
*
* @param proposalList the proposal list
* @param objectClasses the object class
* @param offset the offset
*/
private void addPossibleObjectClasses( List<ICompletionProposal> proposalList, String objectClass, int offset )
{
if ( schema != null )
{
for ( String possibleObjectClass : possibleObjectClasses.keySet() )
{
ObjectClass description = possibleObjectClasses.get( possibleObjectClass );
if ( possibleObjectClass.toUpperCase().startsWith( objectClass.toUpperCase() ) )
{
String replacementString = possibleObjectClass;
String displayString = possibleObjectClass;
if ( displayString.equals( description.getOid() ) )
{
displayString += " (" + SchemaUtils.toString( description ) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
else
{
displayString += " (" + description.getOid() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
ICompletionProposal proposal = new CompletionProposal( replacementString, offset, objectClass
.length(), replacementString.length(), getObjectClassImage(), displayString, null, SchemaUtils
.getLdifLine( schema.getObjectClassDescription( possibleObjectClass ) ) );
proposalList.add( proposal );
}
}
}
}
/**
* Adds the possible matching rules (that fits to the given attribute type) to the proposal list.
*
* @param proposalList the proposal list
* @param matchingRule the matching rule
* @param offset the offset
*/
private void addPossibleMatchingRules( List<ICompletionProposal> proposalList, String matchingRule, int offset,
LdapFilterToken equalsColonToken, LdapFilterToken equalsToken )
{
if ( schema != null )
{
for ( String possibleMatchingRule : possibleMatchingRules.keySet() )
{
if ( possibleMatchingRule.toUpperCase().startsWith( matchingRule.toUpperCase() ) )
{
MatchingRule description = schema.getMatchingRuleDescription( possibleMatchingRule );
String replacementString = possibleMatchingRule;
if ( equalsColonToken == null )
{
replacementString += ":"; //$NON-NLS-1$
}
if ( equalsToken == null )
{
replacementString += "="; //$NON-NLS-1$
}
String displayString = possibleMatchingRule;
if ( displayString.equals( description.getOid() ) )
{
displayString += " (" + SchemaUtils.toString( description ) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
else
{
displayString += " (" + description.getOid() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
String info = SchemaUtils.getLdifLine( description );
ICompletionProposal proposal = new CompletionProposal( replacementString, offset, matchingRule
.length(), replacementString.length(), getMatchingRuleImage(), displayString, null, info );
proposalList.add( proposal );
}
}
}
}
/**
* Adds the dn: proposal to the proposal list.
*
* @param proposalList the proposal list
* @param dnAttr the dn attr
* @param offset the offset
*/
private void addDnAttr( List<ICompletionProposal> proposalList, String dnAttr, int offset )
{
if ( "dn".toUpperCase().startsWith( dnAttr.toUpperCase() ) ) //$NON-NLS-1$
{
String replacementString = "dn:"; //$NON-NLS-1$
String displayString = "dn: ()"; //$NON-NLS-1$
ICompletionProposal proposal = new CompletionProposal( replacementString, offset, dnAttr.length(),
replacementString.length(), null, displayString, null, null );
proposalList.add( proposal );
}
}
/**
* Gets the attribute type image.
*
* @return the attribute type image
*/
private Image getAttributeTypeImage()
{
return BrowserCommonActivator.getDefault().getImage( BrowserCommonConstants.IMG_ATD );
}
/**
* Gets the filter type image.
*
* @return the filter type image
*/
private Image getFilterTypeImage()
{
return BrowserCommonActivator.getDefault().getImage( BrowserCommonConstants.IMG_FILTER_EDITOR );
}
/**
* Gets the object class image.
*
* @return the object class image
*/
private Image getObjectClassImage()
{
return BrowserCommonActivator.getDefault().getImage( BrowserCommonConstants.IMG_OCD );
}
/**
* Gets the matching rule image.
*
* @return the matching rule image
*/
private Image getMatchingRuleImage()
{
return BrowserCommonActivator.getDefault().getImage( BrowserCommonConstants.IMG_MRD );
}
/**
* @see org.eclipse.jface.text.templates.TemplateCompletionProcessor#getTemplates(java.lang.String)
*/
protected Template[] getTemplates( String contextTypeId )
{
Template[] templates = BrowserCommonActivator.getDefault().getFilterTemplateStore().getTemplates(
BrowserCommonConstants.FILTER_TEMPLATE_ID );
return templates;
}
/**
* @see org.eclipse.jface.text.templates.TemplateCompletionProcessor#getContextType(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion)
*/
protected TemplateContextType getContextType( ITextViewer viewer, IRegion region )
{
TemplateContextType contextType = BrowserCommonActivator.getDefault().getFilterTemplateContextTypeRegistry()
.getContextType( BrowserCommonConstants.FILTER_TEMPLATE_ID );
return contextType;
}
/**
* @see org.eclipse.jface.text.templates.TemplateCompletionProcessor#getImage(org.eclipse.jface.text.templates.Template)
*/
protected Image getImage( Template template )
{
return BrowserCommonActivator.getDefault().getImage( BrowserCommonConstants.IMG_TEMPLATE );
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#computeContextInformation(org.eclipse.jface.text.ITextViewer, int)
*/
public IContextInformation[] computeContextInformation( ITextViewer viewer, int documentOffset )
{
return null;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getContextInformationAutoActivationCharacters()
*/
public char[] getContextInformationAutoActivationCharacters()
{
return null;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getErrorMessage()
*/
public String getErrorMessage()
{
return null;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getContextInformationValidator()
*/
public IContextInformationValidator getContextInformationValidator()
{
return null;
}
}