[Rubyeclipse-commit] org.rubypeople.rdt.ui/src/org/rubypeople/rdt/internal/ui/text/ruby RubyFormattingStrategy.java,NONE,1.1 IRubyReconcilingListener.java,NONE,1.1 RubyReconcilingStrategy.java,NONE,1.1

[Christopher W. <caw...@us...>]

Update of /cvsroot/rubyeclipse/org.rubypeople.rdt.ui/src/org/rubypeople/rdt/internal/ui/text/ruby
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv11058/src/org/rubypeople/rdt/internal/ui/text/ruby

Added Files:
	RubyFormattingStrategy.java IRubyReconcilingListener.java 
	RubyReconcilingStrategy.java 
Log Message:
new reconciling files

--- NEW FILE: RubyReconcilingStrategy.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.rubypeople.rdt.internal.ui.text.ruby;


import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.text.Assert;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.reconciler.DirtyRegion;
import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
import org.eclipse.jface.text.source.IAnnotationModel;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;
import org.rubypeople.rdt.core.IRubyScript;
import org.rubypeople.rdt.core.RubyModelException;
import org.rubypeople.rdt.internal.ui.RubyPlugin;
import org.rubypeople.rdt.ui.IWorkingCopyManager;
import org.rubypeople.rdt.ui.RubyUI;


public class RubyReconcilingStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension {


    private ITextEditor fEditor;

    private IWorkingCopyManager fManager;
    private IDocumentProvider fDocumentProvider;
    private IProgressMonitor fProgressMonitor;
    private boolean fNotify= true;

    private IRubyReconcilingListener fRubyReconcilingListener;
    private boolean fIsRubyReconcilingListener;


    public RubyReconcilingStrategy(ITextEditor editor) {
        fEditor= editor;
        fManager= RubyPlugin.getDefault().getWorkingCopyManager();
        fDocumentProvider= RubyPlugin.getDefault().getRubyDocumentProvider();
        fIsRubyReconcilingListener= fEditor instanceof IRubyReconcilingListener;
        if (fIsRubyReconcilingListener)
            fRubyReconcilingListener= (IRubyReconcilingListener)fEditor;
    }

    private IProblemRequestorExtension getProblemRequestorExtension() {
        IAnnotationModel model= fDocumentProvider.getAnnotationModel(fEditor.getEditorInput());
        if (model instanceof IProblemRequestorExtension)
            return (IProblemRequestorExtension) model;
        return null;
    }

    private void reconcile(final boolean initialReconcile) {
        final IRubyScript[] ast= new IRubyScript[1];
        try {
            final IRubyScript unit= fManager.getWorkingCopy(fEditor.getEditorInput());
            if (unit != null) {
                Platform.run(new ISafeRunnable() {
                    public void run() {
                        try {
                            
                            /* fix for missing cancel flag communication */
                            IProblemRequestorExtension extension= getProblemRequestorExtension();
                            if (extension != null) {
                                extension.setProgressMonitor(fProgressMonitor);
                                extension.setIsActive(true);
                            }
                            
                            try {
                                unit.reconcile(true, null, fProgressMonitor);
                            } catch (OperationCanceledException ex) {
                                Assert.isTrue(fProgressMonitor == null || fProgressMonitor.isCanceled());
                                ast[0]= null;
                            } finally {
                                /* fix for missing cancel flag communication */
                                if (extension != null) {
                                    extension.setProgressMonitor(null);
                                    extension.setIsActive(false);
                                }
                            }
                            
                        } catch (RubyModelException ex) {
                            handleException(ex);
                        }
                    }
                    public void handleException(Throwable ex) {
                        IStatus status= new Status(IStatus.ERROR, RubyUI.ID_PLUGIN, IStatus.OK, "Error in JDT Core during reconcile", ex);  //$NON-NLS-1$
                        RubyPlugin.getDefault().getLog().log(status);
                    }
                });
                
            }
        } finally {
            // Always notify listeners, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=55969 for the final solution
            try {
                if (fIsRubyReconcilingListener) {
                    IProgressMonitor pm= fProgressMonitor;
                    if (pm == null)
                        pm= new NullProgressMonitor();
                    fRubyReconcilingListener.reconciled(ast[0], !fNotify, pm);
                }
            } finally {
                fNotify= true;
            }
        }
    }

    /*
     * @see IReconcilingStrategy#reconcile(IRegion)
     */
    public void reconcile(IRegion partition) {
        reconcile(false);
    }

    /*
     * @see IReconcilingStrategy#reconcile(DirtyRegion, IRegion)
     */
    public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
        reconcile(false);
    }

    /*
     * @see IReconcilingStrategy#setDocument(IDocument)
     */
    public void setDocument(IDocument document) {
    }

    /*
     * @see IReconcilingStrategyExtension#setProgressMonitor(IProgressMonitor)
     */
    public void setProgressMonitor(IProgressMonitor monitor) {
        fProgressMonitor= monitor;
    }

    /*
     * @see IReconcilingStrategyExtension#initialReconcile()
     */
    public void initialReconcile() {
        reconcile(true);
    }

    /**
     * Tells this strategy whether to inform its listeners.
     *
     * @param notify <code>true</code> if listeners should be notified
     */
    public void notifyListeners(boolean notify) {
        fNotify= notify;
    }

    /**
     * Called before reconciling is started.
     *
     * @since 3.0
     */
    public void aboutToBeReconciled() {
        if (fIsRubyReconcilingListener)
            fRubyReconcilingListener.aboutToBeReconciled();
    }
}

--- NEW FILE: IRubyReconcilingListener.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.text.ruby;

import org.eclipse.core.runtime.IProgressMonitor;

import org.rubypeople.rdt.core.IRubyScript;


/**
 * Interface of an object listening to Ruby reconciling.
 *
 * @since 3.0
 */
public interface IRubyReconcilingListener {

    /**
     * Called before reconciling is started.
     */
    void aboutToBeReconciled();

    /**
     * Called after reconciling has been finished.
     * @param ast               the ruby script AST or <code>null</code> if
 *                              the working copy was consistent or reconciliation has been cancelled
     * @param forced            <code>true</code> iff this reconciliation was forced
     * @param progressMonitor   the progress monitor
     */
    void reconciled(IRubyScript ast, boolean forced, IProgressMonitor progressMonitor);
}

--- NEW FILE: RubyFormattingStrategy.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.text.ruby;

import java.util.LinkedList;
import java.util.Map;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.TypedPosition;
import org.eclipse.jface.text.formatter.ContextBasedFormattingStrategy;
import org.eclipse.jface.text.formatter.FormattingContextProperties;
import org.eclipse.jface.text.formatter.IFormattingContext;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.TextEdit;
import org.rubypeople.rdt.core.formatter.CodeFormatter;
import org.rubypeople.rdt.internal.corext.util.CodeFormatterUtil;
import org.rubypeople.rdt.internal.ui.RubyPlugin;

/**
 * Formatting strategy for ruby source code.
 *
 * @since 3.0
 */
public class RubyFormattingStrategy extends ContextBasedFormattingStrategy {

    /** Documents to be formatted by this strategy */
    private final LinkedList fDocuments= new LinkedList();
    /** Partitions to be formatted by this strategy */
    private final LinkedList fPartitions= new LinkedList();

    /**
     * Creates a new java formatting strategy.
     */
    public RubyFormattingStrategy() {
        super();
    }

    /*
     * @see org.eclipse.jface.text.formatter.ContextBasedFormattingStrategy#format()
     */
    public void format() {
        super.format();

        final IDocument document= (IDocument)fDocuments.removeFirst();
        final TypedPosition partition= (TypedPosition)fPartitions.removeFirst();

        if (document != null && partition != null) {
            try {

                final TextEdit edit= CodeFormatterUtil.format2(CodeFormatter.K_RUBY_SCRIPT, document.get(), partition.getOffset(), partition.getLength(), 0, TextUtilities.getDefaultLineDelimiter(document), getPreferences());
                if (edit != null) {
                    Map partitioners= null;
                    if (edit.getChildrenSize() > 20)
                        partitioners= TextUtilities.removeDocumentPartitioners(document);

                    edit.apply(document);

                    if (partitioners != null)
                        TextUtilities.addDocumentPartitioners(document, partitioners);
                }

            } catch (MalformedTreeException exception) {
                RubyPlugin.log(exception);
            } catch (BadLocationException exception) {
                // Can only happen on concurrent document modification - log and bail out
                RubyPlugin.log(exception);
            }
        }
    }

    /*
     * @see org.eclipse.jface.text.formatter.ContextBasedFormattingStrategy#formatterStarts(org.eclipse.jface.text.formatter.IFormattingContext)
     */
    public void formatterStarts(final IFormattingContext context) {
        super.formatterStarts(context);

        fPartitions.addLast(context.getProperty(FormattingContextProperties.CONTEXT_PARTITION));
        fDocuments.addLast(context.getProperty(FormattingContextProperties.CONTEXT_MEDIUM));
    }

    /*
     * @see org.eclipse.jface.text.formatter.ContextBasedFormattingStrategy#formatterStops()
     */
    public void formatterStops() {
        super.formatterStops();

        fPartitions.clear();
        fDocuments.clear();
    }
}