diff --git a/.idea/modules.xml b/.idea/modules.xml index 7dd2c78681b2..90f05a8508f1 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,136 +2,238 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jps/model-api/src/org/jetbrains/jps/model/JpsElementFactory.java b/jps/model-api/src/org/jetbrains/jps/model/JpsElementFactory.java index 1e25c2197573..d94c2711bf68 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/JpsElementFactory.java +++ b/jps/model-api/src/org/jetbrains/jps/model/JpsElementFactory.java @@ -1,8 +1,12 @@ package org.jetbrains.jps.model; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.library.JpsLibrary; import org.jetbrains.jps.model.library.JpsLibraryReference; +import org.jetbrains.jps.model.library.JpsLibraryType; +import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleReference; +import org.jetbrains.jps.model.module.JpsModuleType; import org.jetbrains.jps.service.JpsServiceManager; /** @@ -13,6 +17,10 @@ public abstract class JpsElementFactory { return JpsServiceManager.getInstance().getService(JpsElementFactory.class); } + public abstract JpsModule createModule(String name, JpsModuleType type); + + public abstract JpsLibrary createLibrary(@NotNull String name, @NotNull JpsLibraryType type); + @NotNull public abstract JpsModuleReference createModuleReference(@NotNull String moduleName); @@ -20,4 +28,9 @@ public abstract class JpsElementFactory { public abstract JpsLibraryReference createLibraryReference(@NotNull String libraryName, @NotNull JpsElementReference parentReference); + @NotNull + public abstract JpsElementReference createProjectReference(); + + @NotNull + public abstract JpsElementReference createGlobalReference(); } diff --git a/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java b/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java index 0beb26b8a514..9855a4b3d5d8 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java +++ b/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java @@ -24,4 +24,8 @@ public interface JpsProject extends JpsCompositeElement, JpsReferenceableElement @NotNull List getModules(); + + void addModule(JpsModule module); + + void addLibrary(JpsLibrary library); } diff --git a/jps/model-api/src/org/jetbrains/jps/model/java/ExplodedDirectoryModuleExtension.java b/jps/model-api/src/org/jetbrains/jps/model/java/ExplodedDirectoryModuleExtension.java new file mode 100644 index 000000000000..a1fcdb97e3e8 --- /dev/null +++ b/jps/model-api/src/org/jetbrains/jps/model/java/ExplodedDirectoryModuleExtension.java @@ -0,0 +1,18 @@ +package org.jetbrains.jps.model.java; + +import org.jetbrains.jps.model.JpsElement; + +/** + * @author nik + */ +//todo[nik] move to j2me plugin +public interface ExplodedDirectoryModuleExtension extends JpsElement { + + String getExplodedUrl(); + + void setExplodedUrl(String explodedUrl); + + boolean isExcludeExploded(); + + void setExcludeExploded(boolean excludeExploded); +} diff --git a/jps/model-api/src/org/jetbrains/jps/model/java/JpsAnnotationRootType.java b/jps/model-api/src/org/jetbrains/jps/model/java/JpsAnnotationRootType.java new file mode 100644 index 000000000000..51669166ac94 --- /dev/null +++ b/jps/model-api/src/org/jetbrains/jps/model/java/JpsAnnotationRootType.java @@ -0,0 +1,10 @@ +package org.jetbrains.jps.model.java; + +import org.jetbrains.jps.model.library.JpsOrderRootType; + +/** + * @author nik + */ +public class JpsAnnotationRootType extends JpsOrderRootType { + public static final JpsAnnotationRootType INSTANCE = new JpsAnnotationRootType(); +} diff --git a/jps/model-api/src/org/jetbrains/jps/model/java/JpsJavaExtensionService.java b/jps/model-api/src/org/jetbrains/jps/model/java/JpsJavaExtensionService.java new file mode 100644 index 000000000000..a7334ea52c87 --- /dev/null +++ b/jps/model-api/src/org/jetbrains/jps/model/java/JpsJavaExtensionService.java @@ -0,0 +1,31 @@ +package org.jetbrains.jps.model.java; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.JpsElementKind; +import org.jetbrains.jps.model.module.JpsDependencyElement; +import org.jetbrains.jps.model.module.JpsModule; +import org.jetbrains.jps.service.JpsServiceManager; + +/** + * @author nik + */ +public abstract class JpsJavaExtensionService { + public static JpsJavaExtensionService getInstance() { + return JpsServiceManager.getInstance().getService(JpsJavaExtensionService.class); + } + + @NotNull + public abstract JpsJavaModuleExtension getOrCreateModuleExtension(@NotNull JpsModule module); + + @NotNull + public abstract JpsJavaDependencyExtension getOrCreateDependencyExtension(@NotNull JpsDependencyElement dependency); + + @NotNull + public abstract JpsElementKind getModuleExtensionKind(); + + @NotNull + public abstract JpsElementKind getDependencyExtensionKind(); + + @NotNull + public abstract ExplodedDirectoryModuleExtension getOrCreateExplodedDirectoryExtension(@NotNull JpsModule module); +} diff --git a/jps/model-api/src/org/jetbrains/jps/model/java/JavaModuleExtension.java b/jps/model-api/src/org/jetbrains/jps/model/java/JpsJavaModuleExtension.java similarity index 51% rename from jps/model-api/src/org/jetbrains/jps/model/java/JavaModuleExtension.java rename to jps/model-api/src/org/jetbrains/jps/model/java/JpsJavaModuleExtension.java index 1ac6c18b42a4..f2c7bdcc2986 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/java/JavaModuleExtension.java +++ b/jps/model-api/src/org/jetbrains/jps/model/java/JpsJavaModuleExtension.java @@ -1,11 +1,15 @@ package org.jetbrains.jps.model.java; import org.jetbrains.jps.model.JpsElement; +import org.jetbrains.jps.model.JpsUrlList; /** * @author nik */ -public interface JavaModuleExtension extends JpsElement { +public interface JpsJavaModuleExtension extends JpsElement { + JpsUrlList getJavadocRoots(); + + JpsUrlList getAnnotationRoots(); String getOutputUrl(); @@ -18,4 +22,12 @@ public interface JavaModuleExtension extends JpsElement { LanguageLevel getLanguageLevel(); void setLanguageLevel(LanguageLevel languageLevel); + + boolean isInheritOutput(); + + void setInheritOutput(boolean inheritOutput); + + boolean isExcludeOutput(); + + void setExcludeOutput(boolean excludeOutput); } diff --git a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java index 70afc3f5e8ee..707344331440 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java +++ b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java @@ -4,14 +4,16 @@ package org.jetbrains.jps.model.library; * @author nik */ public class JpsLibraryRootType { - public static final JpsLibraryRootType COMPILED = new JpsLibraryRootType(JpsOrderRootType.COMPILED, false); - public static final JpsLibraryRootType SOURCES = new JpsLibraryRootType(JpsOrderRootType.SOURCES, false); + public static final JpsLibraryRootType COMPILED = new JpsLibraryRootType(JpsOrderRootType.COMPILED, false, false); + public static final JpsLibraryRootType SOURCES = new JpsLibraryRootType(JpsOrderRootType.SOURCES, false, false); private final boolean myJarDirectory; + private final boolean myRecursive; private final JpsOrderRootType myType; - public JpsLibraryRootType(JpsOrderRootType type, boolean jarDirectory) { - myType = type; + public JpsLibraryRootType(JpsOrderRootType type, boolean jarDirectory, boolean recursive) { myJarDirectory = jarDirectory; + myRecursive = recursive; + myType = type; } public boolean isJarDirectory() { @@ -21,4 +23,8 @@ public class JpsLibraryRootType { public JpsOrderRootType getType() { return myType; } + + public boolean isRecursive() { + return myRecursive; + } } diff --git a/jps/model-api/src/org/jetbrains/jps/model/module/JpsModule.java b/jps/model-api/src/org/jetbrains/jps/model/module/JpsModule.java index fdc54705c502..88aa5b375f8e 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/module/JpsModule.java +++ b/jps/model-api/src/org/jetbrains/jps/model/module/JpsModule.java @@ -42,6 +42,9 @@ public interface JpsModule extends JpsNamedElement, JpsReferenceableElement type, @NotNull String name); + @NotNull + JpsLibrary addModuleLibrary(@NotNull JpsLibrary library); + void delete(); @NotNull diff --git a/jps/model-api/src/org/jetbrains/jps/service/JpsServiceManager.java b/jps/model-api/src/org/jetbrains/jps/service/JpsServiceManager.java index d24524ca3664..2f86a7898341 100644 --- a/jps/model-api/src/org/jetbrains/jps/service/JpsServiceManager.java +++ b/jps/model-api/src/org/jetbrains/jps/service/JpsServiceManager.java @@ -12,8 +12,11 @@ public abstract class JpsServiceManager { public abstract T getService(Class serviceClass); + public abstract Iterable getExtensions(Class extensionClass); + private static class InstanceHolder { private static final JpsServiceManager INSTANCE; + static { INSTANCE = ServiceLoader.load(JpsServiceManager.class).iterator().next(); } diff --git a/jps/model-impl/src/META-INF/services/org.jetbrains.jps.model.java.JpsJavaExtensionService b/jps/model-impl/src/META-INF/services/org.jetbrains.jps.model.java.JpsJavaExtensionService new file mode 100644 index 000000000000..3d58916622f6 --- /dev/null +++ b/jps/model-impl/src/META-INF/services/org.jetbrains.jps.model.java.JpsJavaExtensionService @@ -0,0 +1 @@ +org.jetbrains.jps.model.java.impl.JpsJavaExtensionServiceImpl \ No newline at end of file diff --git a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsElementFactoryImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsElementFactoryImpl.java index 70492b460fe7..21902607503a 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsElementFactoryImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsElementFactoryImpl.java @@ -2,15 +2,32 @@ package org.jetbrains.jps.model.impl; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.*; +import org.jetbrains.jps.model.library.JpsLibrary; import org.jetbrains.jps.model.library.JpsLibraryReference; +import org.jetbrains.jps.model.library.JpsLibraryType; +import org.jetbrains.jps.model.library.impl.JpsLibraryImpl; import org.jetbrains.jps.model.library.impl.JpsLibraryReferenceImpl; +import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleReference; +import org.jetbrains.jps.model.module.JpsModuleType; +import org.jetbrains.jps.model.module.impl.JpsModuleImpl; import org.jetbrains.jps.model.module.impl.JpsModuleReferenceImpl; /** * @author nik */ public class JpsElementFactoryImpl extends JpsElementFactory { + + @Override + public JpsModule createModule(String name, JpsModuleType type) { + return new JpsModuleImpl(type, name); + } + + @Override + public JpsLibrary createLibrary(@NotNull String name, @NotNull JpsLibraryType type) { + return new JpsLibraryImpl(name, type); + } + @NotNull @Override public JpsModuleReference createModuleReference(@NotNull String moduleName) { @@ -23,4 +40,16 @@ public class JpsElementFactoryImpl extends JpsElementFactory { @NotNull JpsElementReference parentReference) { return new JpsLibraryReferenceImpl(libraryName, parentReference); } + + @NotNull + @Override + public JpsElementReference createProjectReference() { + return new JpsProjectElementReference(); + } + + @NotNull + @Override + public JpsElementReference createGlobalReference() { + return new JpsGlobalElementReference(); + } } diff --git a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsGlobalImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsGlobalImpl.java index c5bb2c500b64..f48ad0d0f365 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsGlobalImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsGlobalImpl.java @@ -23,7 +23,7 @@ public class JpsGlobalImpl extends JpsRootElementBase implements @NotNull @Override public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull final String name) { - final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); + final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); return collection.addChild(new JpsLibraryImpl(name, libraryType)); } diff --git a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java index ff8d13885d40..e70099f276da 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java @@ -17,7 +17,8 @@ import java.util.List; * @author nik */ public class JpsProjectImpl extends JpsRootElementBase implements JpsProject { - private static final JpsElementCollectionKind> EXTERNAL_REFERENCES_COLLECTION_KIND = new JpsElementCollectionKind>(new JpsElementKindBase>("external reference")); + private static final JpsElementCollectionKind> EXTERNAL_REFERENCES_COLLECTION_KIND = + new JpsElementCollectionKind>(new JpsElementKindBase>("external reference")); public JpsProjectImpl(JpsModel model, JpsEventDispatcher eventDispatcher) { super(model, eventDispatcher); @@ -37,14 +38,14 @@ public class JpsProjectImpl extends JpsRootElementBase implement @NotNull @Override public JpsModule addModule(@NotNull JpsModuleType moduleType, @NotNull final String name) { - final JpsElementCollectionImpl collection = myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND); + final JpsElementCollectionImpl collection = myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND); return collection.addChild(new JpsModuleImpl(moduleType, name)); } @NotNull @Override public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull final String name) { - final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); + final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); return collection.addChild(new JpsLibraryImpl(name, libraryType)); } @@ -60,6 +61,16 @@ public class JpsProjectImpl extends JpsRootElementBase implement return myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).getElements(); } + @Override + public void addModule(JpsModule module) { + myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).addChild(module); + } + + @Override + public void addLibrary(JpsLibrary library) { + myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).addChild(library); + } + @NotNull @Override public JpsElementReference createReference() { diff --git a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsUrlListKind.java b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsUrlListKind.java new file mode 100644 index 000000000000..95c6f2e1ac0f --- /dev/null +++ b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsUrlListKind.java @@ -0,0 +1,20 @@ +package org.jetbrains.jps.model.impl; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.JpsElementCreator; +import org.jetbrains.jps.model.JpsUrlList; + +/** + * @author nik + */ +public class JpsUrlListKind extends JpsElementKindBase implements JpsElementCreator { + public JpsUrlListKind(String debugName) { + super(debugName); + } + + @NotNull + @Override + public JpsUrlList create() { + return new JpsUrlListImpl(); + } +} diff --git a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/ExplodedDirectoryModuleExtensionImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/ExplodedDirectoryModuleExtensionImpl.java new file mode 100644 index 000000000000..e8a03bf27cb2 --- /dev/null +++ b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/ExplodedDirectoryModuleExtensionImpl.java @@ -0,0 +1,65 @@ +package org.jetbrains.jps.model.java.impl; + +import com.intellij.openapi.util.Comparing; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.impl.JpsElementBase; +import org.jetbrains.jps.model.impl.JpsElementKindBase; +import org.jetbrains.jps.model.java.ExplodedDirectoryModuleExtension; + +/** + * @author nik + */ +public class ExplodedDirectoryModuleExtensionImpl extends JpsElementBase implements + ExplodedDirectoryModuleExtension { + public static final JpsElementKindBase KIND = + new JpsElementKindBase("exploded directory"); + + private String myExplodedUrl; + private boolean myExcludeExploded; + + public ExplodedDirectoryModuleExtensionImpl() { + } + + public ExplodedDirectoryModuleExtensionImpl(ExplodedDirectoryModuleExtensionImpl original) { + myExcludeExploded = original.myExcludeExploded; + myExplodedUrl = original.myExplodedUrl; + } + + @Override + public String getExplodedUrl() { + return myExplodedUrl; + } + + @Override + public void setExplodedUrl(String explodedUrl) { + if (!Comparing.equal(myExplodedUrl, explodedUrl)) { + myExplodedUrl = explodedUrl; + fireElementChanged(); + } + } + + @Override + public boolean isExcludeExploded() { + return myExcludeExploded; + } + + @Override + public void setExcludeExploded(boolean excludeExploded) { + if (myExcludeExploded != excludeExploded) { + myExcludeExploded = excludeExploded; + fireElementChanged(); + } + } + + @NotNull + @Override + public ExplodedDirectoryModuleExtensionImpl createCopy() { + return new ExplodedDirectoryModuleExtensionImpl(this); + } + + @Override + public void applyChanges(@NotNull ExplodedDirectoryModuleExtensionImpl modified) { + setExcludeExploded(modified.myExcludeExploded); + setExplodedUrl(modified.myExplodedUrl); + } +} diff --git a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionImpl.java deleted file mode 100644 index 4bf2a2b70bc5..000000000000 --- a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionImpl.java +++ /dev/null @@ -1,76 +0,0 @@ -package org.jetbrains.jps.model.java.impl; - -import com.intellij.openapi.util.Comparing; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.impl.JpsElementBase; -import org.jetbrains.jps.model.java.JavaModuleExtension; -import org.jetbrains.jps.model.java.LanguageLevel; - -/** - * @author nik - */ -public class JavaModuleExtensionImpl extends JpsElementBase implements JavaModuleExtension { - private String myOutputUrl; - private String myTestOutputUrl; - private LanguageLevel myLanguageLevel; - - public JavaModuleExtensionImpl() { - } - - public JavaModuleExtensionImpl(JavaModuleExtensionImpl original) { - myOutputUrl = original.myOutputUrl; - myTestOutputUrl = original.myTestOutputUrl; - myLanguageLevel = original.myLanguageLevel; - } - - @NotNull - @Override - public JavaModuleExtensionImpl createCopy() { - return new JavaModuleExtensionImpl(this); - } - - @Override - public String getOutputUrl() { - return myOutputUrl; - } - - @Override - public void setOutputUrl(String outputUrl) { - if (!Comparing.equal(myOutputUrl, outputUrl)) { - myOutputUrl = outputUrl; - fireElementChanged(); - } - } - - @Override - public String getTestOutputUrl() { - return myTestOutputUrl; - } - - @Override - public void setTestOutputUrl(String testOutputUrl) { - if (!Comparing.equal(myTestOutputUrl, testOutputUrl)) { - myTestOutputUrl = testOutputUrl; - fireElementChanged(); - } - } - - @Override - public LanguageLevel getLanguageLevel() { - return myLanguageLevel; - } - - @Override - public void setLanguageLevel(LanguageLevel languageLevel) { - if (!Comparing.equal(myLanguageLevel, languageLevel)) { - myLanguageLevel = languageLevel; - fireElementChanged(); - } - } - - public void applyChanges(@NotNull JavaModuleExtensionImpl modified) { - setLanguageLevel(modified.myLanguageLevel); - setOutputUrl(modified.myOutputUrl); - setTestOutputUrl(modified.myTestOutputUrl); - } -} diff --git a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionKind.java b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionKind.java index 5425a5521da4..d46529ff5010 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionKind.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JavaModuleExtensionKind.java @@ -1,33 +1,23 @@ package org.jetbrains.jps.model.java.impl; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.*; +import org.jetbrains.jps.model.JpsElementCreator; import org.jetbrains.jps.model.impl.JpsElementKindBase; -import org.jetbrains.jps.model.java.JavaModuleExtension; -import org.jetbrains.jps.model.module.JpsModule; /** * @author nik */ -public class JavaModuleExtensionKind extends JpsElementKindBase implements JpsElementCreator { - private static final JavaModuleExtensionKind INSTANCE = new JavaModuleExtensionKind(); +public class JavaModuleExtensionKind extends JpsElementKindBase + implements JpsElementCreator { + public static final JavaModuleExtensionKind INSTANCE = new JavaModuleExtensionKind(); - public JavaModuleExtensionKind() { + private JavaModuleExtensionKind() { super("java module extension"); } @NotNull @Override - public JavaModuleExtensionImpl create() { - return new JavaModuleExtensionImpl(); - } - - @NotNull - public static JavaModuleExtension getExtension(@NotNull JpsModule module) { - JavaModuleExtension child = module.getContainer().getChild(INSTANCE); - if (child == null) { - child = module.getContainer().setChild(INSTANCE); - } - return child; + public JpsJavaModuleExtensionImpl create() { + return new JpsJavaModuleExtensionImpl(); } } diff --git a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaDependencyExtensionKind.java b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaDependencyExtensionKind.java index 0319b55211ca..48555c5b7de7 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaDependencyExtensionKind.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaDependencyExtensionKind.java @@ -1,19 +1,18 @@ package org.jetbrains.jps.model.java.impl; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.*; +import org.jetbrains.jps.model.JpsElementCreator; import org.jetbrains.jps.model.impl.JpsElementKindBase; -import org.jetbrains.jps.model.java.JpsJavaDependencyExtension; import org.jetbrains.jps.model.java.JpsJavaDependencyScope; -import org.jetbrains.jps.model.module.JpsDependencyElement; /** * @author nik */ -public class JpsJavaDependencyExtensionKind extends JpsElementKindBase implements JpsElementCreator { +public class JpsJavaDependencyExtensionKind extends JpsElementKindBase + implements JpsElementCreator { public static final JpsJavaDependencyExtensionKind INSTANCE = new JpsJavaDependencyExtensionKind(); - public JpsJavaDependencyExtensionKind() { + private JpsJavaDependencyExtensionKind() { super("java dependency extension"); } @@ -22,12 +21,4 @@ public class JpsJavaDependencyExtensionKind extends JpsElementKindBase getModuleExtensionKind() { + return JavaModuleExtensionKind.INSTANCE; + } + + @NotNull + @Override + public JpsElementKind getDependencyExtensionKind() { + return JpsJavaDependencyExtensionKind.INSTANCE; + } + + @Override + @NotNull + public ExplodedDirectoryModuleExtension getOrCreateExplodedDirectoryExtension(@NotNull JpsModule module) { + ExplodedDirectoryModuleExtension extension = module.getContainer().getChild(ExplodedDirectoryModuleExtensionImpl.KIND); + if (extension == null) { + extension = module.getContainer().setChild(ExplodedDirectoryModuleExtensionImpl.KIND, new ExplodedDirectoryModuleExtensionImpl()); + } + return extension; + } +} diff --git a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaModuleExtensionImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaModuleExtensionImpl.java new file mode 100644 index 000000000000..0dba7526275a --- /dev/null +++ b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/JpsJavaModuleExtensionImpl.java @@ -0,0 +1,121 @@ +package org.jetbrains.jps.model.java.impl; + +import com.intellij.openapi.util.Comparing; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.JpsUrlList; +import org.jetbrains.jps.model.impl.JpsCompositeElementBase; +import org.jetbrains.jps.model.impl.JpsUrlListKind; +import org.jetbrains.jps.model.java.JpsJavaModuleExtension; +import org.jetbrains.jps.model.java.LanguageLevel; + +/** + * @author nik + */ +public class JpsJavaModuleExtensionImpl extends JpsCompositeElementBase implements JpsJavaModuleExtension { + private static final JpsUrlListKind JAVADOC_ROOTS_KIND = new JpsUrlListKind("javadoc roots"); + private static final JpsUrlListKind ANNOTATIONS_ROOTS_KIND = new JpsUrlListKind("annotation roots"); + private String myOutputUrl; + private String myTestOutputUrl; + private boolean myInheritOutput; + private boolean myExcludeOutput; + private LanguageLevel myLanguageLevel; + + public JpsJavaModuleExtensionImpl() { + myContainer.setChild(JAVADOC_ROOTS_KIND); + myContainer.setChild(ANNOTATIONS_ROOTS_KIND); + } + + public JpsJavaModuleExtensionImpl(JpsJavaModuleExtensionImpl original) { + super(original); + myOutputUrl = original.myOutputUrl; + myTestOutputUrl = original.myTestOutputUrl; + myLanguageLevel = original.myLanguageLevel; + } + + @NotNull + @Override + public JpsJavaModuleExtensionImpl createCopy() { + return new JpsJavaModuleExtensionImpl(this); + } + + @Override + public JpsUrlList getAnnotationRoots() { + return myContainer.getChild(ANNOTATIONS_ROOTS_KIND); + } + + @Override + public JpsUrlList getJavadocRoots() { + return myContainer.getChild(JAVADOC_ROOTS_KIND); + } + + @Override + public String getOutputUrl() { + return myOutputUrl; + } + + @Override + public void setOutputUrl(String outputUrl) { + if (!Comparing.equal(myOutputUrl, outputUrl)) { + myOutputUrl = outputUrl; + fireElementChanged(); + } + } + + @Override + public String getTestOutputUrl() { + return myTestOutputUrl; + } + + @Override + public void setTestOutputUrl(String testOutputUrl) { + if (!Comparing.equal(myTestOutputUrl, testOutputUrl)) { + myTestOutputUrl = testOutputUrl; + fireElementChanged(); + } + } + + @Override + public LanguageLevel getLanguageLevel() { + return myLanguageLevel; + } + + @Override + public void setLanguageLevel(LanguageLevel languageLevel) { + if (!Comparing.equal(myLanguageLevel, languageLevel)) { + myLanguageLevel = languageLevel; + fireElementChanged(); + } + } + + public void applyChanges(@NotNull JpsJavaModuleExtensionImpl modified) { + setLanguageLevel(modified.myLanguageLevel); + setOutputUrl(modified.myOutputUrl); + setTestOutputUrl(modified.myTestOutputUrl); + } + + @Override + public boolean isInheritOutput() { + return myInheritOutput; + } + + @Override + public void setInheritOutput(boolean inheritOutput) { + if (myInheritOutput != inheritOutput) { + myInheritOutput = inheritOutput; + fireElementChanged(); + } + } + + @Override + public boolean isExcludeOutput() { + return myExcludeOutput; + } + + @Override + public void setExcludeOutput(boolean excludeOutput) { + if (myExcludeOutput != excludeOutput) { + myExcludeOutput = excludeOutput; + fireElementChanged(); + } + } +} diff --git a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryImpl.java index 45728e409a93..beb49333b109 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryImpl.java @@ -15,7 +15,8 @@ import java.util.List; * @author nik */ public class JpsLibraryImpl extends JpsNamedCompositeElementBase implements JpsLibrary { - private static final JpsElementCollectionKind LIBRARY_ROOTS_COLLECTION = new JpsElementCollectionKind(JpsLibraryRootKind.INSTANCE); + private static final JpsElementCollectionKind LIBRARY_ROOTS_COLLECTION = + new JpsElementCollectionKind(JpsLibraryRootKind.INSTANCE); private static final JpsTypedDataKind> TYPED_DATA_KIND = new JpsTypedDataKind>(); public JpsLibraryImpl(@NotNull String name, @NotNull JpsLibraryType type) { @@ -65,9 +66,9 @@ public class JpsLibraryImpl extends JpsNamedCompositeElementBase getParent() { + public JpsElementCollectionImpl getParent() { //noinspection unchecked - return (JpsElementCollectionImpl)myParent; + return (JpsElementCollectionImpl)myParent; } @NotNull @@ -80,7 +81,8 @@ public class JpsLibraryImpl extends JpsNamedCompositeElementBase parentReference = ((JpsReferenceableElement)getParent().getParent()).createReference(); + final JpsElementReference parentReference = + ((JpsReferenceableElement)getParent().getParent()).createReference(); return new JpsLibraryReferenceImpl(getName(), parentReference); } } diff --git a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryKind.java b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryKind.java index 9e09aa2d9ec1..c6da7110d833 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryKind.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryKind.java @@ -1,29 +1,30 @@ package org.jetbrains.jps.model.library.impl; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.impl.JpsElementKindBase; import org.jetbrains.jps.model.JpsEventDispatcher; import org.jetbrains.jps.model.impl.JpsElementCollectionKind; +import org.jetbrains.jps.model.impl.JpsElementKindBase; +import org.jetbrains.jps.model.library.JpsLibrary; import org.jetbrains.jps.model.library.JpsLibraryListener; /** * @author nik */ -public class JpsLibraryKind extends JpsElementKindBase { +public class JpsLibraryKind extends JpsElementKindBase { public static final JpsLibraryKind INSTANCE = new JpsLibraryKind(); - public static final JpsElementCollectionKind LIBRARIES_COLLECTION_KIND = new JpsElementCollectionKind(INSTANCE); + public static final JpsElementCollectionKind LIBRARIES_COLLECTION_KIND = new JpsElementCollectionKind(INSTANCE); private JpsLibraryKind() { super("library"); } @Override - public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryImpl element) { + public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibrary element) { dispatcher.getPublisher(JpsLibraryListener.class).libraryAdded(element); } @Override - public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryImpl element) { + public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibrary element) { dispatcher.getPublisher(JpsLibraryListener.class).libraryRemoved(element); } } diff --git a/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleImpl.java index 49fc525c5ee0..adb148b5da3d 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleImpl.java @@ -16,16 +16,17 @@ import java.util.List; */ public class JpsModuleImpl extends JpsNamedCompositeElementBase implements JpsModule { private static final JpsTypedDataKind> TYPED_DATA_KIND = new JpsTypedDataKind>(); - private static final JpsElementKind CONTENT_ROOTS_KIND = new JpsElementKindBase("content roots"); - private static final JpsElementKind EXCLUDED_ROOTS_KIND = new JpsElementKindBase("excluded roots"); - public static final JpsElementKind DEPENDENCIES_LIST_KIND = new JpsElementKindBase("dependencies"); + private static final JpsUrlListKind CONTENT_ROOTS_KIND = new JpsUrlListKind("content roots"); + private static final JpsUrlListKind EXCLUDED_ROOTS_KIND = new JpsUrlListKind("excluded roots"); + public static final JpsElementKind DEPENDENCIES_LIST_KIND = + new JpsElementKindBase("dependencies"); public JpsModuleImpl(JpsModuleType type, @NotNull String name) { super(name); myContainer.setChild(TYPED_DATA_KIND, new JpsTypedDataImpl>(type)); - myContainer.setChild(CONTENT_ROOTS_KIND, new JpsUrlListImpl()); - myContainer.setChild(EXCLUDED_ROOTS_KIND, new JpsUrlListImpl()); + myContainer.setChild(CONTENT_ROOTS_KIND); + myContainer.setChild(EXCLUDED_ROOTS_KIND); myContainer.setChild(DEPENDENCIES_LIST_KIND, new JpsDependenciesListImpl()); myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); myContainer.setChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND); @@ -115,7 +116,12 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase type, @NotNull String name) { - final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); - return collection.addChild(new JpsLibraryImpl(name, type)); + return addModuleLibrary(new JpsLibraryImpl(name, type)); + } + + @NotNull + @Override + public JpsLibrary addModuleLibrary(final @NotNull JpsLibrary library) { + return myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).addChild(library); } } diff --git a/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleKind.java b/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleKind.java index 9fe135efa227..affce588f0b5 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleKind.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleKind.java @@ -2,29 +2,30 @@ package org.jetbrains.jps.model.module.impl; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.JpsElementKind; -import org.jetbrains.jps.model.impl.JpsElementKindBase; import org.jetbrains.jps.model.JpsEventDispatcher; import org.jetbrains.jps.model.impl.JpsElementCollectionKind; +import org.jetbrains.jps.model.impl.JpsElementKindBase; +import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleListener; /** * @author nik */ -public class JpsModuleKind extends JpsElementKindBase { - public static final JpsElementKind INSTANCE = new JpsModuleKind(); - public static final JpsElementCollectionKind MODULE_COLLECTION_KIND = new JpsElementCollectionKind(INSTANCE); +public class JpsModuleKind extends JpsElementKindBase { + public static final JpsElementKind INSTANCE = new JpsModuleKind(); + public static final JpsElementCollectionKind MODULE_COLLECTION_KIND = new JpsElementCollectionKind(INSTANCE); public JpsModuleKind() { super("module"); } @Override - public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModuleImpl element) { + public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModule element) { dispatcher.getPublisher(JpsModuleListener.class).moduleAdded(element); } @Override - public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModuleImpl element) { + public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModule element) { dispatcher.getPublisher(JpsModuleListener.class).moduleRemoved(element); } } diff --git a/jps/model-impl/src/org/jetbrains/jps/service/impl/JpsServiceManagerImpl.java b/jps/model-impl/src/org/jetbrains/jps/service/impl/JpsServiceManagerImpl.java index 4f9c546a4cef..960bcff17879 100644 --- a/jps/model-impl/src/org/jetbrains/jps/service/impl/JpsServiceManagerImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/service/impl/JpsServiceManagerImpl.java @@ -3,6 +3,7 @@ package org.jetbrains.jps.service.impl; import org.jetbrains.jps.service.JpsServiceManager; import java.util.Iterator; +import java.util.List; import java.util.ServiceConfigurationError; import java.util.ServiceLoader; import java.util.concurrent.ConcurrentHashMap; @@ -12,6 +13,7 @@ import java.util.concurrent.ConcurrentHashMap; */ public class JpsServiceManagerImpl extends JpsServiceManager { private final ConcurrentHashMap myServices = new ConcurrentHashMap(); + private final ConcurrentHashMap> myExtensions = new ConcurrentHashMap>(); @Override public T getService(Class serviceClass) { @@ -24,10 +26,16 @@ public class JpsServiceManagerImpl extends JpsServiceManager { } service = iterator.next(); if (iterator.hasNext()) { - throw new ServiceConfigurationError("More than one implementation for " + serviceClass + " found: " + service.getClass() + " and " + iterator.next().getClass()); + throw new ServiceConfigurationError( + "More than one implementation for " + serviceClass + " found: " + service.getClass() + " and " + iterator.next().getClass()); } myServices.putIfAbsent(serviceClass, service); } return service; } + + @Override + public Iterable getExtensions(Class extensionClass) { + return ServiceLoader.load(extensionClass); + } } diff --git a/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsJavaExtensionTest.java b/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsJavaExtensionTest.java index 0b5609390503..3e66b86643d5 100644 --- a/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsJavaExtensionTest.java +++ b/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsJavaExtensionTest.java @@ -1,11 +1,6 @@ package org.jetbrains.jps.model; -import org.jetbrains.jps.model.java.JpsJavaDependencyExtension; -import org.jetbrains.jps.model.java.JpsJavaDependencyScope; -import org.jetbrains.jps.model.java.JpsJavaLibraryType; -import org.jetbrains.jps.model.java.JpsJavaModuleType; -import org.jetbrains.jps.model.java.impl.JavaModuleExtensionKind; -import org.jetbrains.jps.model.java.impl.JpsJavaDependencyExtensionKind; +import org.jetbrains.jps.model.java.*; import org.jetbrains.jps.model.library.JpsLibrary; import org.jetbrains.jps.model.module.JpsDependencyElement; import org.jetbrains.jps.model.module.JpsLibraryDependency; @@ -17,8 +12,10 @@ import org.jetbrains.jps.model.module.JpsModule; public class JpsJavaExtensionTest extends JpsModelTestCase { public void testModule() { final JpsModule module = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "m"); - JavaModuleExtensionKind.getExtension(module).setOutputUrl("file://path"); - assertEquals("file://path", JavaModuleExtensionKind.getExtension(module).getOutputUrl()); + final JpsJavaModuleExtension extension = JpsJavaExtensionService.getInstance().getOrCreateModuleExtension(module); + extension.setOutputUrl("file://path"); + assertEquals("file://path", + module.getContainer().getChild(JpsJavaExtensionService.getInstance().getModuleExtensionKind()).getOutputUrl()); } public void testDependency() { @@ -26,12 +23,14 @@ public class JpsJavaExtensionTest extends JpsModelTestCase { final JpsModule module = model.getProject().addModule(JpsJavaModuleType.INSTANCE, "m"); final JpsLibrary library = model.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "l"); final JpsLibraryDependency dependency = module.getDependenciesList().addLibraryDependency(library); - JpsJavaDependencyExtensionKind.getExtension(dependency).setScope(JpsJavaDependencyScope.TEST); - JpsJavaDependencyExtensionKind.getExtension(dependency).setExported(true); + JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(dependency).setScope(JpsJavaDependencyScope.TEST); + JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(dependency).setExported(true); model.commit(); - final JpsDependencyElement dep = assertOneElement(assertOneElement(myModel.getProject().getModules()).getDependenciesList().getDependencies()); - final JpsJavaDependencyExtension extension = dep.getContainer().getChild(JpsJavaDependencyExtensionKind.INSTANCE); + final JpsDependencyElement dep = + assertOneElement(assertOneElement(myModel.getProject().getModules()).getDependenciesList().getDependencies()); + final JpsJavaDependencyExtension extension = + dep.getContainer().getChild(JpsJavaExtensionService.getInstance().getDependencyExtensionKind()); assertTrue(extension.isExported()); assertSame(JpsJavaDependencyScope.TEST, extension.getScope()); } diff --git a/jps/model-serialization/jps-model-serialization.iml b/jps/model-serialization/jps-model-serialization.iml new file mode 100644 index 000000000000..2ed39f108303 --- /dev/null +++ b/jps/model-serialization/jps-model-serialization.iml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/jps/model-serialization/src/META-INF/services/org.jetbrains.jps.model.serialization.JpsModelLoaderExtension b/jps/model-serialization/src/META-INF/services/org.jetbrains.jps.model.serialization.JpsModelLoaderExtension new file mode 100644 index 000000000000..4a1c8009b1c3 --- /dev/null +++ b/jps/model-serialization/src/META-INF/services/org.jetbrains.jps.model.serialization.JpsModelLoaderExtension @@ -0,0 +1 @@ +org.jetbrains.jps.model.serialization.java.JpsJavaModelLoaderExtension \ No newline at end of file diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsLibraryTableLoader.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsLibraryTableLoader.java new file mode 100644 index 000000000000..ee53d55a93a9 --- /dev/null +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsLibraryTableLoader.java @@ -0,0 +1,84 @@ +package org.jetbrains.jps.model.serialization; + +import com.intellij.openapi.util.JDOMUtil; +import com.intellij.util.containers.MultiMap; +import org.jdom.Element; +import org.jetbrains.jps.model.JpsElementFactory; +import org.jetbrains.jps.model.java.JpsJavaLibraryType; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryRootType; +import org.jetbrains.jps.model.library.JpsLibraryType; +import org.jetbrains.jps.model.library.JpsOrderRootType; +import org.jetbrains.jps.service.JpsServiceManager; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * @author nik + */ +public class JpsLibraryTableLoader { + private static final Map PREDEFINED_ROOT_TYPES = new HashMap(); + + static { + PREDEFINED_ROOT_TYPES.put("CLASSES", JpsOrderRootType.COMPILED); + PREDEFINED_ROOT_TYPES.put("SOURCES", JpsOrderRootType.SOURCES); + } + + public static void loadLibraries(Element libraryTableElement, List result) { + for (Element libraryElement : JDOMUtil.getChildren(libraryTableElement, "library")) { + JpsLibrary library = loadLibrary(libraryElement); + result.add(library); + } + } + + public static JpsLibrary loadLibrary(Element libraryElement) { + String name = libraryElement.getAttributeValue("name"); + String typeId = libraryElement.getAttributeValue("type"); + JpsLibrary library = JpsElementFactory.getInstance().createLibrary(name, getLibraryType(typeId)); + + MultiMap jarDirectories = new MultiMap(); + MultiMap recursiveJarDirectories = new MultiMap(); + for (Element jarDirectory : JDOMUtil.getChildren(libraryElement, "jarDirectory")) { + String url = jarDirectory.getAttributeValue("url"); + String rootType = jarDirectory.getAttributeValue("type"); + boolean recursive = Boolean.parseBoolean(jarDirectory.getAttributeValue("recursive")); + jarDirectories.putValue(getRootType(rootType), url); + if (recursive) { + recursiveJarDirectories.putValue(getRootType(rootType), url); + } + } + for (Element rootsElement : JDOMUtil.getChildren(libraryElement)) { + final String rootTypeId = rootsElement.getName(); + if (!rootTypeId.equals("jarDirectory")) { + final JpsOrderRootType rootType = getRootType(rootTypeId); + for (Element rootElement : JDOMUtil.getChildren(rootsElement, "root")) { + String url = rootElement.getAttributeValue("url"); + final boolean jarDirectory = jarDirectories.get(rootType).contains(url); + final boolean recursive = recursiveJarDirectories.get(rootType).contains(url); + library.addUrl(url, new JpsLibraryRootType(rootType, jarDirectory, recursive)); + } + } + } + return library; + } + + private static JpsOrderRootType getRootType(String rootTypeId) { + final JpsOrderRootType type = PREDEFINED_ROOT_TYPES.get(rootTypeId); + if (type != null) { + return type; + } + for (JpsModelLoaderExtension extension : JpsServiceManager.getInstance().getExtensions(JpsModelLoaderExtension.class)) { + final JpsOrderRootType rootType = extension.getRootType(rootTypeId); + if (rootType != null) { + return rootType; + } + } + return JpsOrderRootType.COMPILED; + } + + private static JpsLibraryType getLibraryType(String typeId) { + return JpsJavaLibraryType.INSTANCE; + } +} diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModelLoaderExtension.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModelLoaderExtension.java new file mode 100644 index 000000000000..6a889b3b7f65 --- /dev/null +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModelLoaderExtension.java @@ -0,0 +1,38 @@ +package org.jetbrains.jps.model.serialization; + +import org.jdom.Element; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jps.model.JpsCompositeElement; +import org.jetbrains.jps.model.JpsElementReference; +import org.jetbrains.jps.model.library.JpsOrderRootType; +import org.jetbrains.jps.model.library.JpsSdkType; +import org.jetbrains.jps.model.module.JpsDependencyElement; +import org.jetbrains.jps.model.module.JpsModule; + +/** + * @author nik + */ +public abstract class JpsModelLoaderExtension { + + public void loadRootModel(@NotNull JpsModule module, @NotNull Element rootModel) { + } + + @Nullable + public JpsOrderRootType getRootType(@NotNull String typeId) { + return null; + } + + @Nullable + public JpsSdkType getSdkType(@NotNull String typeId) { + return null; + } + + public void loadModuleDependencyProperties(JpsDependencyElement dependency, Element orderEntry) { + } + + @Nullable + public JpsElementReference createLibraryTableReference(String tableLevel) { + return null; + } +} diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModuleComponentSerializer.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModuleComponentSerializer.java new file mode 100644 index 000000000000..08befb67ee9b --- /dev/null +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModuleComponentSerializer.java @@ -0,0 +1,15 @@ +package org.jetbrains.jps.model.serialization; + +import org.jdom.Element; +import org.jetbrains.annotations.NotNull; + +/** + * @author nik + */ +public abstract class JpsModuleComponentSerializer { + + @NotNull + public abstract String getComponentName(); + + public abstract void loadComponent(@NotNull Element component); +} diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModuleLoader.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModuleLoader.java new file mode 100644 index 000000000000..17b560a893be --- /dev/null +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsModuleLoader.java @@ -0,0 +1,120 @@ +package org.jetbrains.jps.model.serialization; + +import org.jdom.Element; +import org.jetbrains.jps.model.JpsCompositeElement; +import org.jetbrains.jps.model.JpsElementFactory; +import org.jetbrains.jps.model.JpsElementReference; +import org.jetbrains.jps.model.java.*; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsSdkType; +import org.jetbrains.jps.model.module.*; +import org.jetbrains.jps.service.JpsServiceManager; + +import static com.intellij.openapi.util.JDOMUtil.getChildren; + +/** + * @author nik + */ +public class JpsModuleLoader { + private static final String URL_ATTRIBUTE = "url"; + + public static void loadRootModel(JpsModule module, Element rootModelComponent) { + for (Element contentElement : getChildren(rootModelComponent, "content")) { + final String url = contentElement.getAttributeValue(URL_ATTRIBUTE); + module.getContentRootsList().addUrl(url); + for (Element sourceElement : getChildren(contentElement, "sourceFolder")) { + final String sourceUrl = sourceElement.getAttributeValue(URL_ATTRIBUTE); + final String packagePrefix = sourceElement.getAttributeValue("packagePrefix"); + final boolean testSource = Boolean.parseBoolean(sourceElement.getAttributeValue("isTestSource")); + final JavaSourceRootType rootType = testSource ? JavaSourceRootType.SOURCE : JavaSourceRootType.TEST_SOURCE; + module.addSourceRoot(rootType, sourceUrl, new JavaSourceRootProperties(packagePrefix)); + } + for (Element excludeElement : getChildren(contentElement, "excludeFolder")) { + module.getExcludeRootsList().addUrl(excludeElement.getAttributeValue(URL_ATTRIBUTE)); + } + } + + final JpsDependenciesList dependenciesList = module.getDependenciesList(); + final JpsElementFactory elementFactory = JpsElementFactory.getInstance(); + int moduleLibraryNum = 0; + for (Element orderEntry : getChildren(rootModelComponent, "orderEntry")) { + String type = orderEntry.getAttributeValue("type"); + if ("sourceFolder".equals(type)) { + dependenciesList.addModuleSourceDependency(); + } + else if ("jdk".equals(type)) { + String sdkName = orderEntry.getAttributeValue("jdkName"); + String sdkTypeId = orderEntry.getAttributeValue("jskType"); + final JpsSdkType sdkType = getSdkType(sdkTypeId); + dependenciesList.addSdkDependency(sdkType); + module.getSdkReferencesTable() + .setSdkReference(sdkType, elementFactory.createLibraryReference(sdkName, elementFactory.createGlobalReference())); + } + else if ("inheritedJdk".equals(type)) { + dependenciesList.addSdkDependency(JpsJavaSdkType.INSTANCE); + } + else if ("library".equals(type)) { + String name = orderEntry.getAttributeValue("name"); + String level = orderEntry.getAttributeValue("level"); + final JpsLibraryDependency dependency = + dependenciesList.addLibraryDependency(elementFactory.createLibraryReference(name, createLibraryTableReference(level))); + loadModuleDependencyProperties(dependency, orderEntry); + } + else if ("module-library".equals(type)) { + final Element moduleLibraryElement = orderEntry.getChild("library"); + final JpsLibrary library = JpsLibraryTableLoader.loadLibrary(moduleLibraryElement); + module.addModuleLibrary(library); + + final JpsLibraryDependency dependency = dependenciesList.addLibraryDependency(library); + loadModuleDependencyProperties(dependency, orderEntry); + moduleLibraryNum++; + } + else if ("module".equals(type)) { + String name = orderEntry.getAttributeValue("module-name"); + final JpsModuleDependency dependency = dependenciesList.addModuleDependency(elementFactory.createModuleReference(name)); + loadModuleDependencyProperties(dependency, orderEntry); + } + } + + for (JpsModelLoaderExtension extension : getLoaderExtensions()) { + extension.loadRootModel(module, rootModelComponent); + } + } + + private static void loadModuleDependencyProperties(JpsDependencyElement dependency, Element orderEntry) { + for (JpsModelLoaderExtension extension : getLoaderExtensions()) { + extension.loadModuleDependencyProperties(dependency, orderEntry); + } + } + + private static JpsElementReference createLibraryTableReference(String level) { + JpsElementFactory elementFactory = JpsElementFactory.getInstance(); + if (level.equals("project")) { + return elementFactory.createProjectReference(); + } + if (level.equals("application")) { + return elementFactory.createGlobalReference(); + } + for (JpsModelLoaderExtension extension : getLoaderExtensions()) { + final JpsElementReference reference = extension.createLibraryTableReference(level); + if (reference != null) { + return reference; + } + } + throw new UnsupportedOperationException(); + } + + private static Iterable getLoaderExtensions() { + return JpsServiceManager.getInstance().getExtensions(JpsModelLoaderExtension.class); + } + + public static JpsSdkType getSdkType(String typeId) { + for (JpsModelLoaderExtension extension : getLoaderExtensions()) { + final JpsSdkType type = extension.getSdkType(typeId); + if (type != null) { + return type; + } + } + return JpsJavaSdkType.INSTANCE; + } +} diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java new file mode 100644 index 000000000000..9e68ed669178 --- /dev/null +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java @@ -0,0 +1,144 @@ +package org.jetbrains.jps.model.serialization; + +import com.intellij.openapi.components.ExpandMacroToPathMap; +import com.intellij.openapi.util.JDOMUtil; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.openapi.util.io.FileUtil; +import org.jdom.Element; +import org.jdom.JDOMException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jps.model.JpsElementFactory; +import org.jetbrains.jps.model.JpsGlobal; +import org.jetbrains.jps.model.JpsProject; +import org.jetbrains.jps.model.java.JpsJavaModuleType; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.module.JpsModule; +import org.jetbrains.jps.model.module.JpsModuleType; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; + +/** + * @author nik + */ +public class JpsProjectLoader { + private final JpsGlobal myGlobal; + private final JpsProject myProject; + private ExpandMacroToPathMap myMacroToPathMap; + + public JpsProjectLoader(JpsGlobal global, JpsProject project) { + myGlobal = global; + myProject = project; + } + + public static void loadProject(JpsGlobal global, final JpsProject project, String projectPath) throws IOException { + new JpsProjectLoader(global, project).loadFromPath(projectPath); + } + + public void loadFromPath(String path) throws IOException { + File file = new File(path).getCanonicalFile(); + if (file.isFile() && path.endsWith(".ipr")) { + loadFromIpr(file); + } + else if (file.getName().equals(".idea")) { + loadFromDirectory(file); + } + else { + File ideaDirectory = new File(file, ".idea"); + if (ideaDirectory.exists()) { + loadFromDirectory(ideaDirectory); + } + else { + throw new IOException("Cannot find IntelliJ IDEA project files at " + path); + } + } + } + + private void loadFromDirectory(File dir) { + initMacroMap(dir.getParentFile()); + loadModules(loadRootElement(new File(dir, "modules.xml"))); + final File[] libraryFiles = new File(dir, "libraries").listFiles(); + if (libraryFiles != null) { + for (File libraryFile : libraryFiles) { + if (isXmlFile(libraryFile)) { + loadProjectLibraries(loadRootElement(libraryFile)); + } + } + } + } + + private void loadFromIpr(File iprFile) { + initMacroMap(iprFile.getParentFile()); + final Element root = loadRootElement(iprFile); + loadModules(root); + loadProjectLibraries(findComponent(root, "libraryTable")); + } + + private void initMacroMap(File projectBaseDir) { + myMacroToPathMap = new ExpandMacroToPathMap(); + myMacroToPathMap.addMacroExpand("PROJECT_DIR", FileUtil.toSystemIndependentName(projectBaseDir.getAbsolutePath())); + } + + private Element loadRootElement(final File file) { + try { + final Element element = JDOMUtil.loadDocument(file).getRootElement(); + myMacroToPathMap.substitute(element, SystemInfo.isFileSystemCaseSensitive); + return element; + } + catch (JDOMException e) { + throw new RuntimeException(e); + } + catch (IOException e) { + throw new RuntimeException(e); + } + } + + private static boolean isXmlFile(File file) { + return file.isFile() && FileUtil.getNameWithoutExtension(file).equalsIgnoreCase("xml"); + } + + private void loadProjectLibraries(Element libraryTableElement) { + final ArrayList libraries = new ArrayList(); + JpsLibraryTableLoader.loadLibraries(libraryTableElement, libraries); + for (JpsLibrary library : libraries) { + myProject.addLibrary(library); + } + } + + private void loadModules(Element root) { + Element componentRoot = findComponent(root, "ProjectModuleManager"); + if (componentRoot == null) return; + final Element modules = componentRoot.getChild("modules"); + for (Element moduleElement : JDOMUtil.getChildren(modules, "module")) { + final String path = moduleElement.getAttributeValue("filepath"); + JpsModule module = loadModule(path); + myProject.addModule(module); + } + } + + private JpsModule loadModule(String path) { + final File file = new File(path); + String name = FileUtil.getNameWithoutExtension(file); + final Element moduleRoot = loadRootElement(file); + final String typeId = moduleRoot.getAttributeValue("type"); + final JpsModule module = JpsElementFactory.getInstance().createModule(name, getModuleType(typeId)); + JpsModuleLoader.loadRootModel(module, findComponent(moduleRoot, "NewModuleRootManager")); + return module; + } + + @Nullable + private static Element findComponent(Element root, String componentName) { + for (Element element : JDOMUtil.getChildren(root, "component")) { + if (componentName.equals(element.getAttributeValue("name"))) { + return element; + } + } + return null; + } + + private static JpsModuleType getModuleType(@NotNull String typeId) { + return JpsJavaModuleType.INSTANCE; + } +} diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/JpsJavaModelLoaderExtension.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/JpsJavaModelLoaderExtension.java new file mode 100644 index 000000000000..79f70d0383c4 --- /dev/null +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/JpsJavaModelLoaderExtension.java @@ -0,0 +1,83 @@ +package org.jetbrains.jps.model.serialization.java; + +import com.intellij.openapi.util.JDOMUtil; +import org.jdom.Element; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.JpsUrlList; +import org.jetbrains.jps.model.java.*; +import org.jetbrains.jps.model.library.JpsOrderRootType; +import org.jetbrains.jps.model.module.JpsDependencyElement; +import org.jetbrains.jps.model.module.JpsModule; +import org.jetbrains.jps.model.serialization.JpsModelLoaderExtension; + +/** + * @author nik + */ +public class JpsJavaModelLoaderExtension extends JpsModelLoaderExtension { + @Override + public void loadRootModel(@NotNull JpsModule module, @NotNull Element rootModel) { + loadExplodedDirectoryExtension(module, rootModel); + loadJavaModuleExtension(module, rootModel); + } + + @Override + public void loadModuleDependencyProperties(JpsDependencyElement dependency, Element entry) { + boolean exported = entry.getAttributeValue("exported") != null; + String scopeName = entry.getAttributeValue("scope"); + JpsJavaDependencyScope scope = scopeName != null ? JpsJavaDependencyScope.valueOf(scopeName) : JpsJavaDependencyScope.COMPILE; + + final JpsJavaDependencyExtension extension = JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(dependency); + extension.setExported(exported); + extension.setScope(scope); + } + + @Override + public JpsOrderRootType getRootType(@NotNull String typeId) { + if (typeId.equals("JAVADOC")) { + return JpsOrderRootType.DOCUMENTATION; + } + else if (typeId.equals("ANNOTATIONS")) { + return JpsAnnotationRootType.INSTANCE; + } + return null; + } + + private static void loadExplodedDirectoryExtension(JpsModule module, Element rootModelComponent) { + final Element exploded = rootModelComponent.getChild("exploded"); + if (exploded != null) { + final ExplodedDirectoryModuleExtension extension = + JpsJavaExtensionService.getInstance().getOrCreateExplodedDirectoryExtension(module); + extension.setExcludeExploded(rootModelComponent.getChild("exclude-exploded") != null); + extension.setExplodedUrl(exploded.getAttributeValue("url")); + } + } + + private static void loadJavaModuleExtension(JpsModule module, Element rootModelComponent) { + final JpsJavaModuleExtension extension = JpsJavaExtensionService.getInstance().getOrCreateModuleExtension(module); + final Element outputTag = rootModelComponent.getChild("output"); + if (outputTag != null) { + extension.setOutputUrl(outputTag.getAttributeValue("url")); + } + final Element testOutputTag = rootModelComponent.getChild("output-test"); + if (testOutputTag != null) { + extension.setOutputUrl(testOutputTag.getAttributeValue("url")); + } + extension.setInheritOutput(Boolean.parseBoolean(rootModelComponent.getAttributeValue("inherit-compiler-output"))); + extension.setExcludeOutput(rootModelComponent.getChild("exclude-output") != null); + + loadAdditionalRoots(rootModelComponent, "annotation-paths", extension.getAnnotationRoots()); + loadAdditionalRoots(rootModelComponent, "javadoc-paths", extension.getJavadocRoots()); + + final String languageLevel = rootModelComponent.getAttributeValue("LANGUAGE_LEVEL"); + if (languageLevel != null) { + extension.setLanguageLevel(LanguageLevel.valueOf(languageLevel)); + } + } + + private static void loadAdditionalRoots(Element rootModelComponent, final String rootsTagName, final JpsUrlList result) { + final Element roots = rootModelComponent.getChild(rootsTagName); + for (Element root : JDOMUtil.getChildren(roots, "root")) { + result.addUrl(root.getAttributeValue("url")); + } + } +} diff --git a/jps/model-serialization/testData/iprProject/iprProject.iml b/jps/model-serialization/testData/iprProject/iprProject.iml new file mode 100644 index 000000000000..dbf84a250f51 --- /dev/null +++ b/jps/model-serialization/testData/iprProject/iprProject.iml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jps/model-serialization/testData/iprProject/iprProject.ipr b/jps/model-serialization/testData/iprProject/iprProject.ipr new file mode 100644 index 000000000000..341eae6831cd --- /dev/null +++ b/jps/model-serialization/testData/iprProject/iprProject.ipr @@ -0,0 +1,59 @@ + + + + + $PROJECT_DIR$/out/artifacts/explodedWar + + + + + + + + + + + + + + + $PROJECT_DIR$/out/artifacts/archive + + + + + + + + + + + $PROJECT_DIR$/out/artifacts/files + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModuleSerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModuleSerializationTest.java new file mode 100644 index 000000000000..20087a1e0326 --- /dev/null +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModuleSerializationTest.java @@ -0,0 +1,31 @@ +package org.jetbrains.jps.model.serialization; + +import com.intellij.openapi.application.PathManager; +import org.jetbrains.jps.model.JpsModelTestCase; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.module.JpsModule; + +import java.io.IOException; + +/** + * @author nik + */ +public class JpsModuleSerializationTest extends JpsModelTestCase { + public void test() { + loadProject("iprProject/iprProject.ipr"); + final JpsModule module = assertOneElement(myModel.getProject().getModules()); + assertEquals("iprProject", module.getName()); + final JpsLibrary library = assertOneElement(myModel.getProject().getLibraries()); + assertEquals("junit", library.getName()); + } + + private void loadProject(final String path) { + try { + final String projectPath = PathManager.getHomePath() + "/community/jps/model-serialization/testData/" + path; + JpsProjectLoader.loadProject(myModel.getGlobal(), myModel.getProject(), projectPath); + } + catch (IOException e) { + throw new RuntimeException(e); + } + } +} diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MarkRootAction.java b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MarkRootAction.java index 218937ed2dd4..b821f227bbac 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MarkRootAction.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MarkRootAction.java @@ -23,8 +23,9 @@ import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.Module; import com.intellij.openapi.roots.*; import com.intellij.openapi.util.Ref; -import com.intellij.openapi.vfs.VfsUtil; +import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.openapi.vfs.VirtualFile; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; /** @@ -88,11 +89,11 @@ public class MarkRootAction extends AnAction { } @Nullable - private static ContentEntry findContentEntry(ModifiableRootModel model, VirtualFile vFile) { + public static ContentEntry findContentEntry(@NotNull ModuleRootModel model, @NotNull VirtualFile vFile) { final ContentEntry[] contentEntries = model.getContentEntries(); for (ContentEntry contentEntry : contentEntries) { final VirtualFile contentEntryFile = contentEntry.getFile(); - if (contentEntryFile != null && VfsUtil.isAncestor(contentEntryFile, vFile, false)) { + if (contentEntryFile != null && VfsUtilCore.isAncestor(contentEntryFile, vFile, false)) { return contentEntry; } } diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java index 7c1567c9c435..2fe057da6a9b 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java @@ -90,7 +90,8 @@ public class SMTestRunnerConnectionUtil { runnerSettings, configurationSettings, new CompositeTestLocationProvider(locator), - false); + false, + null); } public static SMTRunnerConsoleView createConsoleWithCustomLocator(@NotNull final String testFrameworkName, @@ -98,7 +99,8 @@ public class SMTestRunnerConnectionUtil { final RunnerSettings runnerSettings, final ConfigurationPerRunnerSettings configurationSettings, @Nullable final TestLocationProvider locator, - final boolean idBasedTreeConstruction) { + final boolean idBasedTreeConstruction, + @Nullable final TestProxyPrinterProvider printerProvider) { // Console final String splitterPropertyName = testFrameworkName + ".Splitter.Proportion"; final SMTRunnerConsoleView console = @@ -109,7 +111,8 @@ public class SMTestRunnerConnectionUtil { super.attachToProcess(processHandler); attachEventsProcessors(consoleProperties, getResultsViewer(), getResultsViewer().getStatisticsPane(), - processHandler, testFrameworkName, locator, idBasedTreeConstruction); + processHandler, testFrameworkName, locator, idBasedTreeConstruction, + printerProvider); } }; console.setHelpId("reference.runToolWindow.testResultsTab"); @@ -213,7 +216,8 @@ public class SMTestRunnerConnectionUtil { final ProcessHandler processHandler, @NotNull final String testFrameworkName, @Nullable final TestLocationProvider locator, - boolean idBasedTreeConstruction) { + boolean idBasedTreeConstruction, + @Nullable TestProxyPrinterProvider printerProvider) { //build messages consumer final OutputToGeneralTestEventsConverter outputConsumer; if (consoleProperties instanceof SMCustomMessagesParsing) { @@ -233,6 +237,9 @@ public class SMTestRunnerConnectionUtil { if (locator != null) { eventsProcessor.setLocator(locator); } + if (printerProvider != null) { + eventsProcessor.setPrinterProvider(printerProvider); + } // ui actions final SMTRunnerUIActionsHandler uiActionsHandler = new SMTRunnerUIActionsHandler(consoleProperties); diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralIdBasedToSMTRunnerEventsConvertor.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralIdBasedToSMTRunnerEventsConvertor.java index 88ce640ae88f..6c9e4153429f 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralIdBasedToSMTRunnerEventsConvertor.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralIdBasedToSMTRunnerEventsConvertor.java @@ -18,6 +18,7 @@ package com.intellij.execution.testframework.sm.runner; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.execution.process.ProcessOutputTypes; +import com.intellij.execution.testframework.Printer; import com.intellij.execution.testframework.sm.SMRunnerUtil; import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil; import com.intellij.execution.testframework.sm.runner.events.*; @@ -48,6 +49,7 @@ public class GeneralIdBasedToSMTRunnerEventsConvertor implements GeneralTestEven private final String myTestFrameworkName; private boolean myIsTestingFinished = false; private TestLocationProvider myLocator = null; + private TestProxyPrinterProvider myTestProxyPrinterProvider = null; public GeneralIdBasedToSMTRunnerEventsConvertor(@NotNull SMTestProxy.SMRootTestProxy testsRootProxy, @NotNull String testFrameworkName) { @@ -112,6 +114,11 @@ public class GeneralIdBasedToSMTRunnerEventsConvertor implements GeneralTestEven }); } + @Override + public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) { + myTestProxyPrinterProvider = printerProvider; + } + public void onTestStarted(@NotNull final TestStartedEvent testStartedEvent) { SMRunnerUtil.addToInvokeLater(new Runnable() { public void run() { @@ -145,6 +152,14 @@ public class GeneralIdBasedToSMTRunnerEventsConvertor implements GeneralTestEven } SMTestProxy childProxy = new SMTestProxy(startedNodeEvent.getName(), suite, startedNodeEvent.getLocationUrl(), true); + TestProxyPrinterProvider printerProvider = myTestProxyPrinterProvider; + String nodeType = startedNodeEvent.getNodeType(); + if (printerProvider != null && nodeType != null) { + Printer printer = printerProvider.getPrinterByType(nodeType, startedNodeEvent.getNodeArgs()); + if (printer != null) { + childProxy.setPreferredPrinter(printer); + } + } childNode = new Node(startedNodeEvent.getId(), parentNode, childProxy); myNodeByIdMap.put(nodeId, childNode); myRunningNodes.add(childNode); diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralTestEventsProcessor.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralTestEventsProcessor.java index 62f9564789df..98f62d10ff1a 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralTestEventsProcessor.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralTestEventsProcessor.java @@ -74,4 +74,6 @@ public interface GeneralTestEventsProcessor extends Disposable { void addEventsListener(@NotNull SMTRunnerEventsListener viewer); void onFinishTesting(); + + void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider); } diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralToSMTRunnerEventsConvertor.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralToSMTRunnerEventsConvertor.java index 2e38c07d0594..4f6d1357283e 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralToSMTRunnerEventsConvertor.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/GeneralToSMTRunnerEventsConvertor.java @@ -113,6 +113,10 @@ public class GeneralToSMTRunnerEventsConvertor implements GeneralTestEventsProce }); } + @Override + public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) { + } + public void onTestStarted(@NotNull final TestStartedEvent testStartedEvent) { SMRunnerUtil.addToInvokeLater(new Runnable() { public void run() { diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/SMTestProxy.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/SMTestProxy.java index edc1b91d5391..c8833bd7de58 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/SMTestProxy.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/SMTestProxy.java @@ -60,6 +60,7 @@ public class SMTestProxy extends AbstractTestProxy { private boolean myIsEmpty = true; TestLocationProvider myLocator = null; private final boolean myPreservePresentableName; + private Printer myPreferredPrinter = null; public SMTestProxy(final String testName, final boolean isSuite, @Nullable final String locationUrl) { @@ -79,6 +80,10 @@ public class SMTestProxy extends AbstractTestProxy { myLocator = locator; } + public void setPreferredPrinter(@NotNull Printer preferredPrinter) { + myPreferredPrinter = preferredPrinter; + } + public boolean isInProgress() { //final SMTestProxy parent = getParent(); @@ -172,8 +177,24 @@ public class SMTestProxy extends AbstractTestProxy { // if parent is being printed then all childs output // should be also send to the same printer child.setPrinter(myPrinter); + if (myPreferredPrinter != null && child.myPreferredPrinter == null) { + child.setPreferredPrinter(myPreferredPrinter); + } } + @Nullable + private Printer getRightPrinter(@Nullable Printer printer) { + if (myPreferredPrinter != null && printer != null) { + return myPreferredPrinter; + } + return printer; + } + + public void setPrinter(Printer printer) { + super.setPrinter(getRightPrinter(printer)); + } + + public String getName() { return myName; } @@ -397,13 +418,14 @@ public class SMTestProxy extends AbstractTestProxy { * @param printer Printer */ public void printOn(final Printer printer) { - super.printOn(printer); + final Printer rightPrinter = getRightPrinter(printer); + super.printOn(rightPrinter); invokeInAlarm(new Runnable() { @Override public void run() { //Tests State, that provide and formats additional output - myState.printOn(printer); + myState.printOn(rightPrinter); } }); } diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/TestProxyPrinterProvider.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/TestProxyPrinterProvider.java new file mode 100644 index 000000000000..7ce468d5d1f5 --- /dev/null +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/TestProxyPrinterProvider.java @@ -0,0 +1,30 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.execution.testframework.sm.runner; + +import com.intellij.execution.testframework.Printer; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * @author Sergey Simonchik + */ +public interface TestProxyPrinterProvider { + + @Nullable + Printer getPrinterByType(@NotNull String nodeType, @Nullable String arguments); + +} diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/BaseStartedNodeEvent.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/BaseStartedNodeEvent.java index 9182d4619b8d..8d597ecbd439 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/BaseStartedNodeEvent.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/BaseStartedNodeEvent.java @@ -26,14 +26,20 @@ public abstract class BaseStartedNodeEvent extends TreeNodeEvent { private final int myParentId; private final String myLocationUrl; + private final String myNodeType; + private final String myNodeArgs; protected BaseStartedNodeEvent(@NotNull String name, int id, int parentId, - @Nullable final String locationUrl) { + @Nullable final String locationUrl, + @Nullable String nodeType, + @Nullable String nodeArgs) { super(name, id); myParentId = parentId; myLocationUrl = locationUrl; + myNodeType = nodeType; + myNodeArgs = nodeArgs; validate(); } @@ -58,6 +64,16 @@ public abstract class BaseStartedNodeEvent extends TreeNodeEvent { return myLocationUrl; } + @Nullable + public String getNodeType() { + return myNodeType; + } + + @Nullable + public String getNodeArgs() { + return myNodeArgs; + } + @Override protected void appendToStringInfo(@NotNull StringBuilder buf) { append(buf, "parentId", myParentId); @@ -68,4 +84,14 @@ public abstract class BaseStartedNodeEvent extends TreeNodeEvent { return TreeNodeEvent.getIntAttribute(message, "parentNodeId"); } + @Nullable + public static String getNodeType(@NotNull MessageWithAttributes message) { + return message.getAttributes().get("nodeType"); + } + + @Nullable + public static String getNodeArgs(@NotNull MessageWithAttributes message) { + return message.getAttributes().get("nodeArgs"); + } + } diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestStartedEvent.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestStartedEvent.java index 05ba2638e401..c1e15f87f012 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestStartedEvent.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestStartedEvent.java @@ -26,11 +26,15 @@ public class TestStartedEvent extends BaseStartedNodeEvent { public TestStartedEvent(@NotNull TestStarted testStarted, @Nullable String locationUrl) { - super(testStarted.getTestName(), TreeNodeEvent.getNodeId(testStarted), - getParentNodeId(testStarted), locationUrl); + super(testStarted.getTestName(), + TreeNodeEvent.getNodeId(testStarted), + getParentNodeId(testStarted), + locationUrl, + BaseStartedNodeEvent.getNodeType(testStarted), + BaseStartedNodeEvent.getNodeArgs(testStarted)); } public TestStartedEvent(@NotNull String name, @Nullable String locationUrl) { - super(name, -1, -1, locationUrl); + super(name, -1, -1, locationUrl, null, null); } } diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestSuiteStartedEvent.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestSuiteStartedEvent.java index 4c761e7471a1..89b279e7a905 100644 --- a/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestSuiteStartedEvent.java +++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/runner/events/TestSuiteStartedEvent.java @@ -26,12 +26,16 @@ public class TestSuiteStartedEvent extends BaseStartedNodeEvent { public TestSuiteStartedEvent(@NotNull TestSuiteStarted suiteStarted, @Nullable String locationUrl) { - super(suiteStarted.getSuiteName(), TreeNodeEvent.getNodeId(suiteStarted), - getParentNodeId(suiteStarted), locationUrl); + super(suiteStarted.getSuiteName(), + TreeNodeEvent.getNodeId(suiteStarted), + getParentNodeId(suiteStarted), + locationUrl, + BaseStartedNodeEvent.getNodeType(suiteStarted), + BaseStartedNodeEvent.getNodeArgs(suiteStarted)); } public TestSuiteStartedEvent(@NotNull String name, @Nullable String locationUrl) { - super(name, -1, -1, locationUrl); + super(name, -1, -1, locationUrl, null, null); } } diff --git a/platform/smRunner/testSrc/com/intellij/execution/testframework/sm/runner/MockGeneralTestEventsProcessorAdapter.java b/platform/smRunner/testSrc/com/intellij/execution/testframework/sm/runner/MockGeneralTestEventsProcessorAdapter.java index 822e4e11520b..c4177badf2b7 100644 --- a/platform/smRunner/testSrc/com/intellij/execution/testframework/sm/runner/MockGeneralTestEventsProcessorAdapter.java +++ b/platform/smRunner/testSrc/com/intellij/execution/testframework/sm/runner/MockGeneralTestEventsProcessorAdapter.java @@ -100,6 +100,10 @@ public class MockGeneralTestEventsProcessorAdapter implements GeneralTestEventsP public void onFinishTesting() { } + @Override + public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) { + } + @Override public void dispose() { myOutputBuffer.setLength(0); diff --git a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTable.java b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTable.java index bcc840cd979e..a4d6b53f2345 100644 --- a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTable.java +++ b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTable.java @@ -85,10 +85,7 @@ public final class PropertyTable extends JBTable implements ComponentSelectionLi public PropertyTable() { setModel(myModel); setSelectionMode(ListSelectionModel.SINGLE_SELECTION); - - JTableHeader tableHeader = getTableHeader(); - tableHeader.setVisible(false); - tableHeader.setPreferredSize(new Dimension()); + showColumns(false); addMouseListener(new MouseTableListener()); getSelectionModel().addListSelectionListener(new ListSelectionListener() { @@ -103,6 +100,12 @@ public final class PropertyTable extends JBTable implements ComponentSelectionLi // TODO: Updates UI after LAF updated } + public void showColumns(boolean value) { + JTableHeader tableHeader = getTableHeader(); + tableHeader.setVisible(value); + tableHeader.setPreferredSize(value ? null : new Dimension()); + } + public void initQuickFixManager(JViewport viewPort) { myQuickFixManager = new QuickFixManager(this, viewPort); } diff --git a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTablePanel.java b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTablePanel.java index 4fdaa227e41d..b37c2fa9bb6d 100644 --- a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTablePanel.java +++ b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/PropertyTablePanel.java @@ -16,10 +16,7 @@ package com.intellij.designer.propertyTable; import com.intellij.designer.DesignerBundle; -import com.intellij.designer.propertyTable.actions.IPropertyTableAction; -import com.intellij.designer.propertyTable.actions.RestoreDefault; -import com.intellij.designer.propertyTable.actions.ShowExpert; -import com.intellij.designer.propertyTable.actions.ShowJavadoc; +import com.intellij.designer.propertyTable.actions.*; import com.intellij.openapi.actionSystem.*; import com.intellij.openapi.actionSystem.impl.ActionButton; import com.intellij.ui.IdeBorderFactory; @@ -61,10 +58,6 @@ public final class PropertyTablePanel extends JPanel implements ListSelectionLis actionGroup.add(new ShowExpert(myPropertyTable)); - PopupHandler.installPopupHandler(myPropertyTable, actionGroup, - ActionPlaces.GUI_DESIGNER_PROPERTY_INSPECTOR_POPUP, - actionManager); - myActions = actionGroup.getChildren(null); for (int i = 0; i < myActions.length; i++) { AnAction action = myActions[i]; @@ -75,6 +68,12 @@ public final class PropertyTablePanel extends JPanel implements ListSelectionLis } } + actionGroup.add(new ShowColumns(myPropertyTable)); + + PopupHandler.installPopupHandler(myPropertyTable, actionGroup, + ActionPlaces.GUI_DESIGNER_PROPERTY_INSPECTOR_POPUP, + actionManager); + myPropertyTable.getSelectionModel().addListSelectionListener(this); valueChanged(null); diff --git a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/actions/ShowColumns.java b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/actions/ShowColumns.java new file mode 100644 index 000000000000..034b9111bbee --- /dev/null +++ b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/propertyTable/actions/ShowColumns.java @@ -0,0 +1,48 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.designer.propertyTable.actions; + +import com.intellij.designer.DesignerBundle; +import com.intellij.designer.propertyTable.PropertyTable; +import com.intellij.openapi.actionSystem.AnActionEvent; +import com.intellij.openapi.actionSystem.Presentation; +import com.intellij.openapi.actionSystem.ToggleAction; + +/** + * @author Alexander Lobas + */ +public class ShowColumns extends ToggleAction { + private final PropertyTable myTable; + + public ShowColumns(PropertyTable table) { + myTable = table; + + Presentation presentation = getTemplatePresentation(); + String text = DesignerBundle.message("designer.properties.show.columns"); + presentation.setText(text); + presentation.setDescription(text); + } + + @Override + public boolean isSelected(AnActionEvent e) { + return myTable.getTableHeader().isVisible(); + } + + @Override + public void setSelected(AnActionEvent e, boolean state) { + myTable.showColumns(state); + } +} \ No newline at end of file diff --git a/plugins/ui-designer/ui-designer-new/src/messages/DesignerBundle.properties b/plugins/ui-designer/ui-designer-new/src/messages/DesignerBundle.properties index 87decad7bb4b..a1c32a1a728a 100644 --- a/plugins/ui-designer/ui-designer-new/src/messages/DesignerBundle.properties +++ b/plugins/ui-designer/ui-designer-new/src/messages/DesignerBundle.properties @@ -7,7 +7,8 @@ command.set.property.value=Set Property Value designer.properties.title=Properties designer.properties.show.expert=Show expert properties -designer.properties.show.javadoc=Show Documentation +designer.properties.show.columns=Show columns +designer.properties.show.javadoc=Show documentation designer.properties.javadoc.title=Documentation for {0} property designer.properties.restore_default=Restore default value designer.properties.column1=Property