View Javadoc
   /* ====================================================================
    * The Apache Software License, Version 1.1
    *
    * Copyright (c) 2000 The Apache Software Foundation.  All rights
    * reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   * Portions of this software are based upon public domain software
   * originally written at the National Center for Supercomputing Applications,
   * University of Illinois, Urbana-Champaign.
   */
  package com.bonevich.eclipse.logging.popups;
  
  import com.bonevich.eclipse.logging.LoggingPlugin;
  import com.bonevich.eclipse.logging.LoggingPluginMessages;
  import com.bonevich.eclipse.logging.LoggingPluginResources;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.eclipse.core.resources.IProject;
  import org.eclipse.core.runtime.*;
  import org.eclipse.jdt.core.*;
  import org.eclipse.jface.text.*;
  import org.eclipse.jface.text.IRegion;
  import org.eclipse.ui.IFileEditorInput;
  import org.eclipse.ui.actions.WorkspaceModifyOperation;
  import org.eclipse.ui.texteditor.ITextEditor;
  
  import java.lang.reflect.InvocationTargetException;
  import java.util.StringTokenizer;
  
  /***
   * Workhorse for adding logging statements to a given source code editor.
   * 
   * @author jbonevic
   */
  public class AddLoggingOperation
  	extends WorkspaceModifyOperation
  	implements LoggingPluginResources
  {
  	private static final Log _logger = LogFactory.getLog(AddLoggingOperation.class);
  	
  	private static final String DUPLICATE = "duplicate entry";
  	private static final String EXISTS = "already exists";
  	
  	private ITextEditor _editor;
  	private ICompilationUnit _unit;
  	private AddLoggingAction _action;
  	private boolean _saveWork = true;
  
  	public AddLoggingOperation(
  		ITextEditor editor,
  		ICompilationUnit cu,
 		AddLoggingAction action,
 		boolean saveWork)
 	{
 		super();
 		_editor = editor;
 		_unit = cu;
 		_action = action;
 		_saveWork = saveWork;
 	}
 
 	/***
 	 * @see WorkspaceModifyOperation#execute(IProgressMonitor)
 	 */
 	protected void execute(IProgressMonitor monitor)
 		throws CoreException, InvocationTargetException, InterruptedException
 	{
 		if (monitor == null)
 		{
 			monitor = new NullProgressMonitor();
 		}
 		monitor.beginTask(LoggingPluginMessages.bind(ADD_LOGGING_DIALOG), 3);
 
 		IDocument document = _editor.getDocumentProvider().getDocument(_editor.getEditorInput());
 		String lineDelimiter = getLineDelimiter(document);
 		int tabWidth = getTabWidth();
 		String loggingImpl = LoggingPlugin.getPlugin().getLoggingImplementationPreference();
 		
 		linkLoggerLibrary(loggingImpl, monitor);
 		monitor.worked(1);
 
 		addLoggerImports(loggingImpl);
 		monitor.worked(1);
 
 		addLoggerField(loggingImpl, lineDelimiter, tabWidth);
 		monitor.worked(1);
 
 		addLoggingStatement(loggingImpl, document, lineDelimiter, tabWidth);
 		monitor.done();
 	}
 
 	private void linkLoggerLibrary(String loggingImpl, IProgressMonitor monitor)
 	{
 		if (! LoggingPlugin.LOGGING_PREFS_API_JDK_1_4.equals(loggingImpl))
 		{
 			String name = LoggingPluginMessages.bind(LOGGING_LIB_PATHVAR + loggingImpl);
 			IClasspathEntry variableEntry = JavaCore.newVariableEntry(new Path(name), null, null, true);
 			
 			IFileEditorInput input = (IFileEditorInput) _editor.getEditorInput(); 
 			IProject project = input.getFile().getProject();
 			IJavaProject javaProject = JavaCore.create(project);
 			try
 			{
 				IClasspathEntry[] classpathEntries = javaProject.getRawClasspath();
 				IClasspathEntry[] newEntries = new IClasspathEntry[classpathEntries.length + 1];
 				System.arraycopy(classpathEntries, 0 , newEntries, 0, classpathEntries.length);
 				newEntries[newEntries.length - 1] = variableEntry;
 				javaProject.setRawClasspath(newEntries, monitor);
 			}
 			catch (JavaModelException e)
 			{
 				if (e.getMessage().indexOf(DUPLICATE) < 0)
 				{
 					_logger.error("Error adding library", e);
 				}
 			}
 
 		}
 	}
 
 	private void addLoggerImports(String loggingImpl) throws JavaModelException
 	{
 		String imports = LoggingPluginMessages.bind(LOGGING_IMPORT_CLASS + loggingImpl);
 		StringTokenizer tokenizer = new StringTokenizer(imports, " ,");
 		while (tokenizer.hasMoreTokens())
 		{
 			_unit.createImport(tokenizer.nextToken(), null, null);
 		}
 	}
 
 	private void addLoggerField(String loggingImpl, String lineDelimiter, int tabWidth) throws JavaModelException
 	{
 		IType[] types = _unit.getTypes();
 		if (types.length > 0)
 		{
 			IType type = types[0];
 			int indentLevel = getIndentationLevel(type, tabWidth) + 1;
 
 			String field = LoggingPluginMessages.bind(
 				LOGGING_FIELD_DECLARATION + loggingImpl, 
 				LoggingPlugin.getPlugin().getFieldNamePreference(),
 				type.getElementName()
 			);
 
 			String formattedField = formatStatement(field + lineDelimiter, lineDelimiter, indentLevel);
 
 			try
 			{
 				type.createField(formattedField, null, false, null);
 			}
 			catch (JavaModelException e)
 			{
 				// name collisions should be ignored - if a field already exists, do not fail
 				if (e.getMessage().indexOf(EXISTS) < 0)
 				{
 					_logger.error("Failed to add field", e);
 				}
 			}
 		}
 	}
 
 	private void addLoggingStatement(String loggingImpl, IDocument document, String lineDelimiter, int tabWidth)
 	{
 		try
 		{
 			ITextSelection selection = (ITextSelection) _editor.getSelectionProvider().getSelection();
 			int offset = selection.getOffset();
 			IRegion lineInfo = document.getLineInformationOfOffset(offset);
 			int lineOffset = lineInfo.getOffset();
 			int lineLength = lineInfo.getLength();
 			int indentLevel = getIndentationLevel(document.get(lineOffset, lineLength), tabWidth);
 			int eolOffset = lineOffset + lineLength;
 			document.replace(eolOffset, 0, lineDelimiter);
 
 			String statement = null;
 			if (_action.isConditionalUsed())
 			{
 				statement = _action.getConditionalLoggingStatement(loggingImpl);
 			}
 			else
 			{
 				statement = _action.getLoggingStatement(loggingImpl);
 			}
 
 			String formatterStatement = formatStatement(statement, lineDelimiter, indentLevel);
 
 			// append the formatted logging statement to this line
 			document.replace(eolOffset + lineDelimiter.length(), 0, formatterStatement);
 		}
 		catch (BadLocationException ignore)
 		{
 		}
 	}
 
 	private String formatStatement(String statement, String lineDelimiter, int indentLevel)
 	{
 		ICodeFormatter formatter = ToolFactory.createDefaultCodeFormatter(null);
 		return formatter.format(statement, indentLevel, null, lineDelimiter);
 	}
 
 	private String getLineDelimiter(IDocument document)
 	{
 		String delim = null;
 		try
 		{
 			delim = document.getLineDelimiter(0);
 		}
 		catch (BadLocationException e)
 		{
 			String[] delims = document.getLegalLineDelimiters();
 			if (delims.length > 0)
 			{
 				delim = delims[0];
 			}
 			if (delim == null)
 			{
 				delim = System.getProperty("line.separator", "\n");
 			}
 		}
 		return delim;
 	}
 
 	private int getIndentationLevel(IType type, int tabWidth)
 	{
 		try
 		{
 			IBuffer buf = _unit.getBuffer();
 			int offset = type.getSourceRange().getOffset();
 			int count = 0;
 			int blanks = 0;
 			while (offset > 0)
 			{
 				char ch = buf.getChar(offset--);
 				switch (ch)
 				{
 					case '\t' :
 						++count;
 						blanks = 0;
 						break;
 					case ' ' :
 						if (++blanks == tabWidth)
 						{
 							++count;
 							blanks = 0;
 						}
 						break;
 					default :
 						return count;
 				}
 			}
 			return count;
 		}
 		catch (JavaModelException e)
 		{
 			return 0;
 		}
 	}
 
 	private int getIndentationLevel(String line, int tabWidth)
 	{
 		int count = 0;
 		int blanks = 0;
 		int length = line.length();
 		for (int i = 0; i < length; i++)
 		{
 			char ch = line.charAt(i);
 			switch (ch)
 			{
 				case '\t' :
 					++count;
 					blanks = 0;
 					break;
 				case ' ' :
 					if (++blanks == tabWidth)
 					{
 						++count;
 						blanks = 0;
 					}
 					break;
 				default :
 					return count;
 			}
 		}
 		return count;
 	}
 	
 	private int getTabWidth()
 	{
 		return Integer.parseInt(JavaCore.getOption(JavaCore.FORMATTER_TAB_SIZE));
 	}
 }