aprire un progetto eclipse specifico dalla riga di comando

Question

Lavoro con molti progetti java piccoli, ma non correlati. Ho creato uno script Ant che crea automaticamente .project e .classpath ogni volta che creo un nuovo progetto, con le librerie e il nome del progetto necessari. Mi piacerebbe essere in grado di aprire Eclipse con quel progetto, dalla riga di comando. In questo momento lo faccio manualmente, chiudendo il vecchio progetto aperto nell'area di lavoro, quindi eseguo un'importazione e trova il nuovo progetto. Non sono riuscito a trovare un modo per farlo da Ant o batch. Posso aprire Eclipse, ma viene fuori l'ultimo spazio di lavoro/progetto. Non importa se dovessi creare un singolo spazio/progetto, ma non so come farlo da una sceneggiatura. Grazie per eventuali suggerimenti.

Answer 1

Vorrei raccomandare contro facendo questo come in realtà non è che molto sforzo per importare il progetto usando le procedure guidate standard. Mi concentrerei sulla chiusura dei progetti non attivi (vedi più sotto).

Modifica: se non si è sicuri di utilizzare ant per portare i progetti nello spazio di lavoro, è possibile implementare un plug-in facendo qualcosa come il seguente codice.

Chiudi i vecchi progetti o li cancelli? Non vedo alcun motivo per eliminarli effettivamente. Se si chiudono tutti i progetti su cui non si sta lavorando (fare clic con il pulsante destro del mouse su di essi e selezionare Chiudi progetto o selezionare il progetto desiderato e fare clic con il pulsante destro del mouse -> chiudere progetti non correlati), vengono ignorati dalla piattaforma in modo tale da non influire sullo sviluppo di il progetto aperto.

Per nascondere i progetti chiusi dalla visualizzazione, è possibile fare clic verso il basso che puntano triangolo nell'angolo superiore destro della Package Explorer vista, selezionare Filtri ... e nel Selezionare gli elementi da escludere dal la vista: lista verifica l'opzione Progetti chiusi.

---

Questo è un plugin che leggerà una serie di nomi da un file nella directory principale di lavoro, eliminare tutti i progetti esistenti (senza rimuovere il contenuto) e creare i nuovi progetti nello spazio di lavoro. L'uso è a proprio rischio, nessuna responsabilità bla bla.

Prendere i contenuti e inserirli nei file pertinenti ed è possibile impacchettare un plugin Eclipse. Ti consiglio di utilizzare un'installazione Eclipse separata (in realtà mi raccomando di non utilizzarla affatto) poiché verrà eseguita ogni volta che trova il file newjects.txt nella root dell'area di lavoro.

La dichiarazione nel file plugin.xml implementa un punto di estensione Eclipse richiamato dopo l'inizializzazione del workbench. Viene chiamato il metodo earlyStartup() di StartupHelper. Crea un nuovo Runnable che viene eseguito in modo asincrono (questo significa che il caricamento dell'area di lavoro non verrà bloccato se questo plugin ha problemi). Il Runnable legge le righe dal magico file newprojects.txt che si aspetta di vedere nella root dell'area di lavoro. Se trova dei contenuti, cancella/crea i progetti.

Aggiornamento: L'aiutante è stato modificato per consentire progetti da creare al di fuori dello spazio di lavoro, se si definisce un valore in newprojects.txt si presume che è l'URI assoluto del progetto. Si noti che non sfugge alla stringa, quindi se si è su una piattaforma Windows, utilizzare doppie barre sul percorso.

contenuto Esempio:

#will be created in the workspace 
project1 
#will be created at c:\test\project2 
project2=c:\\test\project2 

buona fortuna!

/META-INF/MANIFEST.MF:

Manifest-Version: 1.0 
Bundle-ManifestVersion: 2 
Bundle-Name: Project fettling Plug-in 
Bundle-SymbolicName: name.seller.rich;singleton:=true 
Bundle-Version: 1.0.0 
Bundle-Activator: name.seller.rich.Activator 
Require-Bundle: org.eclipse.core.runtime, 
org.eclipse.ui.workbench;bundle-version="3.4.1", 
org.eclipse.swt;bundle-version="3.4.1", 
org.eclipse.core.resources;bundle-version="3.4.1" 
Bundle-ActivationPolicy: lazy 

/plugin.xml:

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.0"?> 
<plugin> 
    <extension 
     point="org.eclipse.ui.startup"> 
     <startup class="name.seller.rich.projectloader.StartupHelper"/>      
    </extension> 
</plugin> 

/.project:

<?xml version="1.0" encoding="UTF-8"?> 
<projectDescription> 
    <name>name.seller.rich.projectloader</name> 
    <comment></comment> 
    <projects> 
    </projects> 
    <buildSpec> 
     <buildCommand> 
      <name>org.eclipse.jdt.core.javabuilder</name> 
      <arguments> 
      </arguments> 
     </buildCommand> 
     <buildCommand> 
      <name>org.eclipse.pde.ManifestBuilder</name> 
      <arguments> 
      </arguments> 
     </buildCommand> 
     <buildCommand> 
      <name>org.eclipse.pde.SchemaBuilder</name> 
      <arguments> 
      </arguments> 
     </buildCommand> 
    </buildSpec> 
    <natures> 
     <nature>org.eclipse.pde.PluginNature</nature> 
     <nature>org.eclipse.jdt.core.javanature</nature> 
    </natures> 
</projectDescription> 

/.classpath:

<?xml version="1.0" encoding="UTF-8"?> 
<classpath> 
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> 
    <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/> 
    <classpathentry kind="src" path="src/main/java"/> 
    <classpathentry kind="output" path="target/classes"/> 
</classpath> 

/src/main/java/name/seller/rich/Activator.java:

package name.seller.rich; 

import org.eclipse.core.runtime.Plugin; 
import org.osgi.framework.BundleContext; 

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

    // The plug-in ID 
    public static final String PLUGIN_ID = "name.seller.rich"; 

    // The shared instance 
    private static Activator plugin; 

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

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

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

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

} 

/src/main/java/nome/venditore/ricco/projectloader/StartupHelper .java:

package name.seller.rich.projectloader; 

import java.io.File; 
import java.io.FileInputStream; 
import java.util.Map; 
import java.util.Properties; 

import name.seller.rich.Activator; 

import org.eclipse.core.internal.resources.ProjectDescription; 
import org.eclipse.core.resources.IProject; 
import org.eclipse.core.resources.IWorkspaceRoot; 
import org.eclipse.core.resources.ResourcesPlugin; 
import org.eclipse.core.runtime.IPath; 
import org.eclipse.core.runtime.IProgressMonitor; 
import org.eclipse.core.runtime.IStatus; 
import org.eclipse.core.runtime.NullProgressMonitor; 
import org.eclipse.core.runtime.Path; 
import org.eclipse.core.runtime.Status; 
import org.eclipse.ui.IStartup; 
import org.eclipse.ui.IWorkbench; 
import org.eclipse.ui.PlatformUI; 

public class StartupHelper implements IStartup { 

    private static final class DirtyHookRunnable implements Runnable { 
     private IWorkspaceRoot workspaceRoot; 

     private DirtyHookRunnable(final IWorkspaceRoot workspaceRoot) { 
      this.workspaceRoot = workspaceRoot; 
     } 

     public void run() { 

      try { 
       IPath workspaceLocation = this.workspaceRoot.getLocation(); 

       File startupFile = new File(workspaceLocation.toOSString(), 
         "newprojects.txt"); 

       IProgressMonitor monitor = new NullProgressMonitor(); 

       Properties properties = new Properties(); 
       if (startupFile.exists()) { 
        properties.load(new FileInputStream(startupFile)); 
       } 
       if (properties.size() > 0) { 
        // delete existing projects 
        IProject[] projects = this.workspaceRoot.getProjects(); 

        for (IProject project : projects) { 
         // don't delete the content 
         project.delete(false, true, monitor); 
        } 

        // create new projects 
        for (Map.Entry entry : properties.entrySet()) { 
         IProject project = this.workspaceRoot 
           .getProject((String) entry.getKey()); 

         // insert into loop 
         ProjectDescription projectDescription = new ProjectDescription(); 
         projectDescription.setName((String) entry.getKey()); 

         String location = (String) entry.getValue(); 

         // value will be empty String if no "=" on the line 
         // in that case it will be created in the workspace 
         // WARNING, currently windows paths must be escaped, 
         // e.g. c:\\test\\myproject 
         if (location.length() > 0) { 
          IPath locationPath = new Path(location); 
          projectDescription.setLocation(locationPath); 
         } 

         project.create(projectDescription, monitor); 

         // project.create(monitor); 
         project.open(monitor); 
        } 
       } 
      } catch (Exception e) { 
       IStatus status = new Status(IStatus.INFO, Activator.PLUGIN_ID, 
         0, "unable to load new projects", null); 
       Activator.getDefault().getLog().log(status); 
      } 
     } 
    } 

    public StartupHelper() { 
     super(); 
    } 

    public final void earlyStartup() { 

     IWorkbench workbench = PlatformUI.getWorkbench(); 
     IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); 

     workbench.getDisplay().asyncExec(new DirtyHookRunnable(workspaceRoot)); 
    } 
} 

Answer 2

soluzione parziale: Aprire Eclipse in un'area di lavoro specificato:

eclipse.exe -data c: \ code \ area_di_lavoro

Answer 3

Un altro possible option viene fornito su this question. L'essenza della risposta è, se è stato installato CDT, si può fare:

eclipse -nosplash 
    -application org.eclipse.cdt.managedbuilder.core.headlessbuild 
    -import  {[uri:/]/path/to/project} 
    -importAll {[uri:/]/path/to/projectTreeURI} Import all projects under URI 
    -build  {project_name | all} 
    -cleanBuild {projec_name | all} 

Il trucco è che può importare qualsiasi progetto, non solo i progetti C.