Wtyczka eclipse nie działa po aktualizacji do juno (eclipse 4)

Question

Utworzyłem plugin do zaćmienia, który zostanie przechwycony w akcji składowania, aby utworzyć zminimalizowany plik javascript z kompilatorem zamykającym goolge. Zobacz pliki poniżej. To działało aż do zaćmienia 3.7.2. Niestety teraz w Eclipse 4.2.1 wydaje się, że czasami tworzy to nieskończoną pętlę. Wydaje się, że przyczyną była praca "compile .min.js" (linia 64 w ResourceChangedListener.java). Powoduje to, że obszar roboczy zaczyna się budować w kółko. Domyślam się, że dzieje się tak dlatego, że to zadanie tworzy lub zmienia plik uruchamiający ponownie kompilację przestrzeni roboczej, co ponownie uruchamia zadanie, które uruchamia kompilację i tak dalej. Ale nie mogę wymyślić, jak temu zapobiec.

// Activator.java

package closure_compiler_save; 

import org.eclipse.core.resources.ResourcesPlugin; 
import org.eclipse.ui.plugin.AbstractUIPlugin; 
import org.osgi.framework.BundleContext; 

/** 
* The activator class controls the plug-in life cycle 
*/ 
public class Activator extends AbstractUIPlugin { 

    // The plug-in ID 
    public static final String PLUGIN_ID = "closure-compiler-save"; //$NON-NLS-1$ 

    // The shared instance 
    private static Activator plugin; 

    /** 
    * The constructor 
    */ 
    public Activator() { 
    } 

    @Override 
     public void start(BundleContext context) throws Exception { 
     super.start(context); 
     Activator.plugin = this; 

     ResourceChangedListener listener = new ResourceChangedListener(); 
      ResourcesPlugin.getWorkspace().addResourceChangeListener(listener); 
    } 

    @Override 
     public void stop(BundleContext context) throws Exception { 
     Activator.plugin = null; 
     super.stop(context); 
    } 

    /** 
    * Returns the shared instance 
    * 
    * @return the shared instance 
    */ 
    public static Activator getDefault() { 
     return plugin; 
    } 
} 

// ResourceChangedListener.java

package closure_compiler_save; 

import java.io.ByteArrayInputStream; 
import java.io.IOException; 
import java.io.InputStream; 

import org.eclipse.core.resources.IFile; 
import org.eclipse.core.resources.IProject; 
import org.eclipse.core.resources.IResource; 
import org.eclipse.core.resources.IResourceChangeEvent; 
import org.eclipse.core.resources.IResourceChangeListener; 
import org.eclipse.core.resources.IResourceDelta; 
import org.eclipse.core.runtime.CoreException; 
import org.eclipse.core.runtime.IPath; 
import org.eclipse.core.runtime.IProgressMonitor; 
import org.eclipse.core.runtime.IStatus; 
import org.eclipse.core.runtime.Status; 
import org.eclipse.core.runtime.jobs.Job; 

public class ResourceChangedListener implements IResourceChangeListener { 

    public void resourceChanged(IResourceChangeEvent event) { 
     if (event.getType() != IResourceChangeEvent.POST_CHANGE) 
      return; 

     IResourceDelta delta = event.getDelta(); 
     try { 
      processDelta(delta); 
     } catch (CoreException e) { 
      e.printStackTrace(); 
     } 
    } 

    // find out which class files were just built 
    private void processDelta(IResourceDelta delta) throws CoreException { 

     IResourceDelta[] kids = delta.getAffectedChildren(); 
     for (IResourceDelta delta2 : kids) { 
      if (delta2.getAffectedChildren().length == 0) { 
       if (delta.getKind() != IResourceDelta.CHANGED) 
        return; 

       IResource res = delta2.getResource(); 
       if (res.getType() == IResource.FILE && "js".equalsIgnoreCase(res.getFileExtension())) { 
        if (res.getName().contains("min")) 
         return; 
        compile(res); 
       } 
      } 
      processDelta(delta2); 
     } 
    } 

    private void compile(final IResource res) throws CoreException { 

     final IPath fullPath = res.getFullPath(); 
     final IPath fullLocation = res.getLocation(); 
     final String fileName = fullPath.lastSegment().toString(); 
     final String outputFilename = fileName.substring(0, fileName.lastIndexOf(".")).concat(".min.js"); 
     final String outputPath = fullPath.removeFirstSegments(1).removeLastSegments(1).toString(); 

     final IProject project = res.getProject(); 
     final IFile newFile = project.getFile(outputPath.concat("/".concat(outputFilename))); 
     Job compileJob = new Job("Compile .min.js") { 
      public IStatus run(IProgressMonitor monitor) { 
       byte[] bytes = null; 
       try { 
        bytes = CallCompiler.compile(fullLocation.toString(), CallCompiler.SIMPLE_OPTIMIZATION).getBytes(); 

        InputStream source = new ByteArrayInputStream(bytes); 
        if (!newFile.exists()) { 
         newFile.create(source, IResource.NONE, null); 
        } else { 
         newFile.setContents(source, IResource.NONE, null); 
        } 
       } catch (IOException e) { 
        e.printStackTrace(); 
       } catch (CoreException e) { 
        e.printStackTrace(); 
       } 
       return Status.OK_STATUS; 
      } 
     }; 
     compileJob.setRule(newFile.getProject()); // this will ensure that no two jobs are writing simultaneously on the same file 
     compileJob.schedule(); 
    } 

} 

Answer 1

Po tym jak skonfigurować puste zaćmienie klasyczny środowiska, rozpoczęła nowy projekt tam plugin Zaćmienie i odtworzone wszystkie pliki to dziala ponownie częściowo. W tym środowisku, rozpoczynając sesję debugowania, mogę zapisać pliki .js i pliki .min.js są tworzone automatycznie. Jak dotąd, dobrze! Ale kiedy zainstaluję wtyczkę do mojego realnie rozwijającego się środowiska Eclipse, automatyczne zapisywanie nie działa.

Przynajmniej jeden krok dalej!

Krok 2: Niektóre pliki nie zostały uwzględnione w kompilacji, oczywiście potrzebne, jak manifest. Nie mam pojęcia, dlaczego zostały one cofnięte. W każdym razie wydaje się, po prostu ustawienie puste Eclipse 4 classic i przechodząc przez kreatora wtyczki eclipse naprawiono mój pierwotny problem. Nadal chciałbym wiedzieć, jaki był rzeczywisty problem ...