Otwórz konkretny projekt zaćmienia z wiersza polecenia

Question

Pracuję z wieloma małymi, ale niepowiązanymi projektami java. Zrobiłem skrypt Ant, który tworzy .project i .classpath automatycznie, gdy tylko utworzę nowy projekt, z potrzebnymi bibliotekami i nazwą projektu. Chciałbym móc otworzyć Eclipse z tym projektem, z linii poleceń. Teraz robię to ręcznie, zamykając stary otwarty projekt w obszarze roboczym, a następnie wykonuję import i znajduję nowy projekt. Nie mogłem znaleźć sposobu, aby to zrobić z Ant lub partii. Mogę otworzyć Eclipse, ale pojawia się ostatni obszar roboczy/projekt. Nie mam nic przeciwko, gdybym musiał stworzyć indywidualną przestrzeń roboczą/projekt, ale nie wiem, jak to zrobić ze skryptu. Dziękuję za wszelkie sugestie.

Answer 1

polecam przeciwko robią to, ponieważ nie jest aż tak wiele wysiłku, aby importuj projekt za pomocą standardowych kreatorów. Skupiłbym się na zamknięciu nieaktywnych projektów (więcej informacji poniżej).

Edycja: Jeśli nie możesz już użyć mrówki do przeniesienia projektów do obszaru roboczego, możesz zaimplementować wtyczkę wykonując kod podobny do poniższego.

Czy zamykasz stare projekty lub je usuwasz? Nie widzę powodu, aby je faktycznie usunąć. Jeśli zamkniesz wszystkie projekty, nad którymi nie pracujesz (kliknij prawym przyciskiem myszy i wybierz zamknij projekt lub wybierz odpowiedni projekt i kliknij prawym przyciskiem myszy-> zamknij niepowiązane projekty), zostaną one zignorowane przez platformę, więc nie wpłyną na rozwój otwarty projekt.

Aby ukryć zamkniętych projektów z widoku, można kliknąć trójkąt w dół w prawym górnym rogu Package Explorer widoku wybierz Filtry ... aw Wybierz elementy do wyłączenia z widok: lista sprawdź opcję Zamknięte projekty.

---

Jest to plugin, który będzie czytać zbiór nazw z pliku w katalogu głównym obszarze roboczym, należy usunąć wszystkie istniejące projekty (bez usuwania zawartości) i tworzenie nowych projektów w obszarze roboczym. Używanie odbywa się na własne ryzyko, bez odpowiedzialności blah blah.

Przenieś zawartość i umieść je w odpowiednich plikach, a możesz spakować plugin Eclipse. Zalecam używanie oddzielnej instalacji Eclipse (w rzeczywistości zalecam jej używanie w ogóle), ponieważ będzie ona uruchamiana za każdym razem, gdy znajdzie nowy plik .proxt w katalogu głównym obszaru roboczego.

Deklaracja w pliku plugin.xml implementuje punkt rozszerzenia Eclipse, który jest wywoływany po zainicjowaniu środowiska roboczego. Zostaje wywołana metoda earlyStartup() obiektu StartupHelper. Tworzy nowy Runnable, który jest wykonywany asynchronicznie (oznacza to, że ładowanie przestrzeni roboczej nie zostanie zablokowane, jeśli ta wtyczka ma problemy). Runnable odczytuje linie z pliku magicproject.txt, który spodziewa się zobaczyć w katalogu głównym obszaru roboczego. Jeśli znajdzie jakiekolwiek treści, usunie/utworzy projekty.

Aktualizacja: Pomocnik został zmodyfikowany, aby umożliwić projekty mają być utworzone poza obszar roboczy, jeśli określić wartość w newprojects.txt Zakłada się, że jest absolutnym URI projektu. Zauważ, że nie wymyka się ciągowi znaków, więc jeśli korzystasz z platformy Windows, użyj podwójnych ukośników na ścieżce.

Przykład Zawartość:

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

powodzenia!

/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/nazwa/sprzedawca/bogaty/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

Częściowe rozwiązanie: Open zaćmienie w określonym obszarze roboczym:

eclipse.exe -data c: \ workspace-kryptonimem \

Answer 3

Kolejne possible option podano na this question. Istotą jest odpowiedź, jeśli CDT zainstalowany, można zrobić:

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} 

Sztuką jest to, że można go zaimportować dowolny projekt, nie tylko projekty C.