abrir un proyecto de eclipse específico desde la línea de comando

Question

Trabajo con muchos proyectos java pequeños pero no relacionados. Hice un script Ant que crea .project y .classpath automáticamente cada vez que creo un nuevo proyecto, con las bibliotecas necesarias y el nombre del proyecto. Me gustaría poder abrir Eclipse con ese proyecto, desde la línea de comandos. En este momento lo hago de forma manual, cerrando el viejo proyecto abierto en el área de trabajo, luego hago una importación y encuentro el nuevo proyecto. No pude encontrar una manera de hacerlo desde Ant o por lotes. Puedo abrir Eclipse, pero aparece el último espacio de trabajo/proyecto. No me importa si tendría que crear un espacio de trabajo/proyecto individual, pero no sé cómo hacerlo desde un script. Gracias por cualquier sugerencia.

Answer 1

yo recomendaría en contra de hacer esto, ya que no es realmente mucho esfuerzo importar el proyecto usando los asistentes estándar. Me centraría en cerrar los proyectos inactivos (ver más abajo).

Editar: Si no está seguro de usar hormiga para llevar los proyectos al espacio de trabajo, puede implementar un complemento que haga algo como el siguiente código.

¿Cierra los proyectos anteriores o los elimina? No veo ninguna razón para eliminarlos. Si cierra todos los proyectos en los que no está trabajando (haga clic derecho en ellos y seleccione cerrar proyecto o seleccione el proyecto que desea y haga clic derecho-> cerrar proyectos no relacionados), la plataforma los ignorará, por lo que no afectará el desarrollo de el proyecto abierto.

Para ocultar los proyectos cerrados desde el punto de vista, puede hacer clic en los que apunta hacia abajo triángulo en la esquina superior derecha de la vistaExplorador de paquetes, seleccione Filtros ... y en el Seleccionar los elementos a excluir de la vista: lista marca proyectos cerrados opción.

---

Este es un plugin que leerá un conjunto de nombres de un archivo en la raíz del espacio de trabajo, eliminar todos los proyectos existentes (sin quitar el contenido) y crear los nuevos proyectos en el área de trabajo. El uso es bajo su propio riesgo, sin responsabilidad, bla, bla.

Tome los contenidos y colóquelos en los archivos pertinentes y puede empaquetar un plugin de Eclipse. Recomiendo usar una instalación de Eclipse por separado (en realidad, recomiendo no usarla en absoluto), ya que se ejecutará cada vez que encuentre los nuevos proyectos.txt en la raíz del espacio de trabajo.

La declaración en el plugin.xml implementa un punto de extensión de Eclipse que se invoca después de que se inicializa el banco de trabajo. Se llama al método earlyStartup() del StartupHelper. Crea un Runnable nuevo que se ejecuta de forma asincrónica (esto significa que la carga del espacio de trabajo no se bloqueará si este plugin tiene problemas). Runnable lee líneas del archivo magic newprojects.txt que espera ver en la raíz del espacio de trabajo. Si encuentra algún contenido, eliminará/creará los proyectos.

Actualización: El ayudante se ha modificado para permitir que los proyectos se crean fuera del área de trabajo, si se define un valor en newprojects.txt se supone que es el URI absoluto del proyecto. Tenga en cuenta que no escapa a la cadena, por lo que si se encuentra en una plataforma de Windows, use barras dobles en la ruta.

contenidos Ejemplo:

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

buena suerte!

/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/nombre/vendedor/rico/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

solución parcial: Eclipse abierto en un espacio de trabajo especificado:

eclipse.exe -datos c: \ code \ nombre-área-

Answer 3

Otro possible option se da en this question. La esencia de la respuesta es, si ha instalado CDT, que puede hacer:

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} 

El truco aquí es que puede importar cualquier proyecto, no sólo los proyectos de C.