From b0012df3fbea5e7bf35ad8df4a211a75964d2d83 Mon Sep 17 00:00:00 2001 From: nik Date: Tue, 19 Jun 2012 15:39:22 +0400 Subject: [PATCH] implemented read access to library which delegates to the new project model --- .../org/jetbrains/jps/model/JpsGlobal.java | 4 +- .../org/jetbrains/jps/model/JpsProject.java | 16 +- .../jps/model/library/JpsLibrary.java | 8 +- .../model/library/JpsLibraryCollection.java | 18 ++ .../jps/model/library/JpsLibraryRoot.java | 7 +- .../jps/model/library/JpsLibraryRootType.java | 30 --- .../jetbrains/jps/model/module/JpsModule.java | 9 +- .../jps/model/impl/JpsGlobalImpl.java | 22 +- .../jps/model/impl/JpsProjectImpl.java | 30 +-- .../impl/JpsLibraryCollectionImpl.java | 37 ++++ .../model/library/impl/JpsLibraryImpl.java | 38 ++-- .../library/impl/JpsLibraryRootImpl.java | 18 +- .../library/impl/JpsLibraryRootKind.java | 9 +- .../jps/model/module/impl/JpsModuleImpl.java | 25 ++- .../jetbrains/jps/model/JpsLibraryTest.java | 16 +- .../serialization/JpsLibraryTableLoader.java | 17 +- .../model/serialization/JpsProjectLoader.java | 2 +- .../JpsModuleSerializationTest.java | 2 +- .../impl/library/JpsLibraryDelegate.java | 209 ++++++++++++++++++ .../impl/library/JpsLibraryTableImpl.java | 189 ++++++++++++++++ .../impl/module/content/JpsContentEntry.java | 53 ++++- .../impl/module/content/JpsSourceFolder.java | 4 + .../dependencies/JpsExportableOrderEntry.java | 4 +- .../dependencies/JpsModuleOrderEntry.java | 19 +- 24 files changed, 649 insertions(+), 137 deletions(-) create mode 100644 jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryCollection.java delete mode 100644 jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java create mode 100644 jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryCollectionImpl.java create mode 100644 platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryDelegate.java create mode 100644 platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryTableImpl.java diff --git a/jps/model-api/src/org/jetbrains/jps/model/JpsGlobal.java b/jps/model-api/src/org/jetbrains/jps/model/JpsGlobal.java index ea535b091670..b602f1363de1 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/JpsGlobal.java +++ b/jps/model-api/src/org/jetbrains/jps/model/JpsGlobal.java @@ -2,6 +2,7 @@ package org.jetbrains.jps.model; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; import org.jetbrains.jps.model.library.JpsLibraryType; /** @@ -11,5 +12,6 @@ public interface JpsGlobal extends JpsCompositeElement, JpsReferenceableElement< @NotNull JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, final @NotNull String name); - + @NotNull + JpsLibraryCollection getLibraryCollection(); } 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 9855a4b3d5d8..5c093dee34d0 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java +++ b/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java @@ -2,6 +2,7 @@ package org.jetbrains.jps.model; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; import org.jetbrains.jps.model.library.JpsLibraryType; import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleType; @@ -16,16 +17,15 @@ public interface JpsProject extends JpsCompositeElement, JpsReferenceableElement @NotNull JpsModule addModule(@NotNull JpsModuleType moduleType, @NotNull String name); + void addModule(@NotNull JpsModule module); + + @NotNull + List getModules(); + + @NotNull JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull String name); @NotNull - List getLibraries(); - - @NotNull - List getModules(); - - void addModule(JpsModule module); - - void addLibrary(JpsLibrary library); + JpsLibraryCollection getLibraryCollection(); } diff --git a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibrary.java b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibrary.java index 1d79c0bcc107..4c94fca2439a 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibrary.java +++ b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibrary.java @@ -12,11 +12,13 @@ import java.util.List; public interface JpsLibrary extends JpsNamedElement, JpsReferenceableElement { @NotNull - List getUrls(@NotNull JpsLibraryRootType rootType); + List getRoots(@NotNull JpsOrderRootType rootType); - void addUrl(@NotNull String url, @NotNull JpsLibraryRootType rootType); + void addRoot(@NotNull String url, @NotNull JpsOrderRootType rootType); - void removeUrl(@NotNull String url, @NotNull JpsLibraryRootType rootType); + void addRoot(@NotNull String url, @NotNull JpsOrderRootType rootType, @NotNull JpsLibraryRoot.InclusionOptions options); + + void removeUrl(@NotNull String url, @NotNull JpsOrderRootType rootType); void delete(); diff --git a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryCollection.java b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryCollection.java new file mode 100644 index 000000000000..3f1dfc0c84ef --- /dev/null +++ b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryCollection.java @@ -0,0 +1,18 @@ +package org.jetbrains.jps.model.library; + +import org.jetbrains.annotations.NotNull; + +import java.util.List; + +/** + * @author nik + */ +public interface JpsLibraryCollection { + @NotNull + JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull String name); + + @NotNull + List getLibraries(); + + void addLibrary(@NotNull JpsLibrary library); +} diff --git a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRoot.java b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRoot.java index 49254236d441..6654ecfa99a9 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRoot.java +++ b/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRoot.java @@ -8,11 +8,16 @@ import org.jetbrains.jps.model.JpsElement; */ public interface JpsLibraryRoot extends JpsElement { @NotNull - JpsLibraryRootType getRootType(); + JpsOrderRootType getRootType(); @NotNull String getUrl(); + @NotNull + InclusionOptions getInclusionOptions(); + @NotNull JpsLibrary getLibrary(); + + enum InclusionOptions {ROOT_ITSELF, ARCHIVES_UNDER_ROOT, ARCHIVES_UNDER_ROOT_RECURSIVELY} } 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 deleted file mode 100644 index 707344331440..000000000000 --- a/jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java +++ /dev/null @@ -1,30 +0,0 @@ -package org.jetbrains.jps.model.library; - -/** - * @author nik - */ -public class JpsLibraryRootType { - 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, boolean recursive) { - myJarDirectory = jarDirectory; - myRecursive = recursive; - myType = type; - } - - public boolean isJarDirectory() { - return myJarDirectory; - } - - 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 88aa5b375f8e..03fb7ff6878e 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 @@ -3,6 +3,7 @@ package org.jetbrains.jps.model.module; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.*; import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; import org.jetbrains.jps.model.library.JpsLibraryType; import java.util.List; @@ -42,11 +43,13 @@ public interface JpsModule extends JpsNamedElement, JpsReferenceableElement type, @NotNull String name); - @NotNull - JpsLibrary addModuleLibrary(@NotNull JpsLibrary library); + void addModuleLibrary(@NotNull JpsLibrary library); - void delete(); + @NotNull + JpsLibraryCollection getLibraryCollection(); @NotNull JpsSdkReferencesTable getSdkReferencesTable(); + + void delete(); } 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 f48ad0d0f365..9cf7dbdf0730 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 @@ -1,30 +1,42 @@ package org.jetbrains.jps.model.impl; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.*; +import org.jetbrains.jps.model.JpsElementReference; +import org.jetbrains.jps.model.JpsEventDispatcher; +import org.jetbrains.jps.model.JpsGlobal; +import org.jetbrains.jps.model.JpsModel; import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; import org.jetbrains.jps.model.library.JpsLibraryType; -import org.jetbrains.jps.model.library.impl.JpsLibraryImpl; +import org.jetbrains.jps.model.library.impl.JpsLibraryCollectionImpl; import org.jetbrains.jps.model.library.impl.JpsLibraryKind; /** * @author nik */ public class JpsGlobalImpl extends JpsRootElementBase implements JpsGlobal { + private final JpsLibraryCollectionImpl myLibraryCollection; + public JpsGlobalImpl(JpsModel model, JpsEventDispatcher eventDispatcher) { super(model, eventDispatcher); - myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); + myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND)); } public JpsGlobalImpl(JpsGlobalImpl original, JpsModel model, JpsEventDispatcher eventDispatcher) { super(original, model, eventDispatcher); + myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND)); } @NotNull @Override public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull final String name) { - final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); - return collection.addChild(new JpsLibraryImpl(name, libraryType)); + return myLibraryCollection.addLibrary(libraryType, name); + } + + @NotNull + @Override + public JpsLibraryCollection getLibraryCollection() { + return myLibraryCollection; } @NotNull 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 e70099f276da..d1f835eb914e 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 @@ -1,10 +1,14 @@ package org.jetbrains.jps.model.impl; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.*; +import org.jetbrains.jps.model.JpsElementReference; +import org.jetbrains.jps.model.JpsEventDispatcher; +import org.jetbrains.jps.model.JpsModel; +import org.jetbrains.jps.model.JpsProject; import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; import org.jetbrains.jps.model.library.JpsLibraryType; -import org.jetbrains.jps.model.library.impl.JpsLibraryImpl; +import org.jetbrains.jps.model.library.impl.JpsLibraryCollectionImpl; import org.jetbrains.jps.model.library.impl.JpsLibraryKind; import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleType; @@ -19,16 +23,18 @@ import java.util.List; public class JpsProjectImpl extends JpsRootElementBase implements JpsProject { private static final JpsElementCollectionKind> EXTERNAL_REFERENCES_COLLECTION_KIND = new JpsElementCollectionKind>(new JpsElementKindBase>("external reference")); + private final JpsLibraryCollection myLibraryCollection; public JpsProjectImpl(JpsModel model, JpsEventDispatcher eventDispatcher) { super(model, eventDispatcher); myContainer.setChild(JpsModuleKind.MODULE_COLLECTION_KIND); - myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); myContainer.setChild(EXTERNAL_REFERENCES_COLLECTION_KIND); + myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND)); } public JpsProjectImpl(JpsProjectImpl original, JpsModel model, JpsEventDispatcher eventDispatcher) { super(original, model, eventDispatcher); + myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND)); } public void addExternalReference(@NotNull JpsElementReference reference) { @@ -45,30 +51,24 @@ public class JpsProjectImpl extends JpsRootElementBase implement @NotNull @Override public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull final String name) { - final JpsElementCollectionImpl collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND); - return collection.addChild(new JpsLibraryImpl(name, libraryType)); + return myLibraryCollection.addLibrary(libraryType, name); } @NotNull @Override - public List getLibraries() { - return myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).getElements(); - } - - @NotNull - @Override - public List getModules() { + public List getModules() { return myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).getElements(); } @Override - public void addModule(JpsModule module) { + public void addModule(@NotNull JpsModule module) { myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).addChild(module); } + @NotNull @Override - public void addLibrary(JpsLibrary library) { - myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).addChild(library); + public JpsLibraryCollection getLibraryCollection() { + return myLibraryCollection; } @NotNull diff --git a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryCollectionImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryCollectionImpl.java new file mode 100644 index 000000000000..8fba7b9e49bd --- /dev/null +++ b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryCollectionImpl.java @@ -0,0 +1,37 @@ +package org.jetbrains.jps.model.library.impl; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.JpsElementCollection; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; +import org.jetbrains.jps.model.library.JpsLibraryType; + +import java.util.List; + +/** + * @author nik + */ +public class JpsLibraryCollectionImpl implements JpsLibraryCollection { + private final JpsElementCollection myCollection; + + public JpsLibraryCollectionImpl(JpsElementCollection collection) { + myCollection = collection; + } + + @NotNull + @Override + public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull String name) { + return myCollection.addChild(new JpsLibraryImpl(name, libraryType)); + } + + @NotNull + @Override + public List getLibraries() { + return myCollection.getElements(); + } + + @Override + public void addLibrary(@NotNull JpsLibrary library) { + myCollection.addChild(library); + } +} 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 beb49333b109..995d25cef8a6 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 @@ -3,20 +3,16 @@ package org.jetbrains.jps.model.library.impl; import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.*; import org.jetbrains.jps.model.impl.*; -import org.jetbrains.jps.model.library.JpsLibrary; -import org.jetbrains.jps.model.library.JpsLibraryReference; -import org.jetbrains.jps.model.library.JpsLibraryRootType; -import org.jetbrains.jps.model.library.JpsLibraryType; +import org.jetbrains.jps.model.library.*; -import java.util.ArrayList; 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) { @@ -31,29 +27,29 @@ public class JpsLibraryImpl extends JpsNamedCompositeElementBase getUrls(@NotNull JpsLibraryRootType rootType) { - final List urls = new ArrayList(); - for (JpsLibraryRootImpl root : getRootsCollection().getElements()) { - if (root.getRootType().equals(rootType)) { - urls.add(root.getUrl()); - } - } - return urls; + public List getRoots(@NotNull JpsOrderRootType rootType) { + return getRootsCollection().getElements(); } @Override - public void addUrl(@NotNull final String url, @NotNull final JpsLibraryRootType rootType) { - getRootsCollection().addChild(new JpsLibraryRootImpl(url, rootType)); + public void addRoot(@NotNull String url, @NotNull JpsOrderRootType rootType) { + addRoot(url, rootType, JpsLibraryRoot.InclusionOptions.ROOT_ITSELF); } - private JpsElementCollectionImpl getRootsCollection() { + @Override + public void addRoot(@NotNull final String url, @NotNull final JpsOrderRootType rootType, + @NotNull JpsLibraryRoot.InclusionOptions options) { + getRootsCollection().addChild(new JpsLibraryRootImpl(url, rootType, options)); + } + + private JpsElementCollectionImpl getRootsCollection() { return myContainer.getChild(LIBRARY_ROOTS_COLLECTION); } @Override - public void removeUrl(@NotNull final String url, @NotNull final JpsLibraryRootType rootType) { - final JpsElementCollectionImpl rootsCollection = getRootsCollection(); - for (JpsLibraryRootImpl root : rootsCollection.getElements()) { + public void removeUrl(@NotNull final String url, @NotNull final JpsOrderRootType rootType) { + final JpsElementCollection rootsCollection = getRootsCollection(); + for (JpsLibraryRoot root : rootsCollection.getElements()) { if (root.getUrl().equals(url) && root.getRootType().equals(rootType)) { rootsCollection.removeChild(root); break; diff --git a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootImpl.java index 33dc41361b98..215968d9efc3 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootImpl.java @@ -4,29 +4,31 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.model.impl.JpsElementBase; import org.jetbrains.jps.model.library.JpsLibrary; import org.jetbrains.jps.model.library.JpsLibraryRoot; -import org.jetbrains.jps.model.library.JpsLibraryRootType; +import org.jetbrains.jps.model.library.JpsOrderRootType; /** * @author nik */ public class JpsLibraryRootImpl extends JpsElementBase implements JpsLibraryRoot { private final String myUrl; - private final JpsLibraryRootType myRootType; + private final JpsOrderRootType myRootType; + private final InclusionOptions myOptions; - public JpsLibraryRootImpl(@NotNull String url, - @NotNull JpsLibraryRootType rootType) { + public JpsLibraryRootImpl(@NotNull String url, @NotNull JpsOrderRootType rootType, @NotNull InclusionOptions options) { myUrl = url; myRootType = rootType; + myOptions = options; } public JpsLibraryRootImpl(JpsLibraryRootImpl original) { myUrl = original.myUrl; myRootType = original.myRootType; + myOptions = original.myOptions; } @NotNull @Override - public JpsLibraryRootType getRootType() { + public JpsOrderRootType getRootType() { return myRootType; } @@ -35,6 +37,12 @@ public class JpsLibraryRootImpl extends JpsElementBase imple return myUrl; } + @NotNull + @Override + public InclusionOptions getInclusionOptions() { + return myOptions; + } + @NotNull @Override public JpsLibraryRootImpl createCopy() { diff --git a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootKind.java b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootKind.java index f01d8cc843c6..27822254b0df 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootKind.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootKind.java @@ -1,14 +1,15 @@ 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.JpsElementKindBase; +import org.jetbrains.jps.model.library.JpsLibraryRoot; import org.jetbrains.jps.model.library.JpsLibraryRootListener; /** * @author nik */ -public class JpsLibraryRootKind extends JpsElementKindBase { +public class JpsLibraryRootKind extends JpsElementKindBase { public static final JpsLibraryRootKind INSTANCE = new JpsLibraryRootKind(); public JpsLibraryRootKind() { @@ -16,12 +17,12 @@ public class JpsLibraryRootKind extends JpsElementKindBase { } @Override - public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRootImpl element) { + public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRoot element) { dispatcher.getPublisher(JpsLibraryRootListener.class).rootAdded(element); } @Override - public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRootImpl element) { + public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRoot element) { dispatcher.getPublisher(JpsLibraryRootListener.class).rootRemoved(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 adb148b5da3d..97f6e96bdfaf 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 @@ -1,11 +1,14 @@ package org.jetbrains.jps.model.module.impl; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.model.*; +import org.jetbrains.jps.model.JpsElementKind; +import org.jetbrains.jps.model.JpsElementProperties; +import org.jetbrains.jps.model.JpsUrlList; import org.jetbrains.jps.model.impl.*; import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; import org.jetbrains.jps.model.library.JpsLibraryType; -import org.jetbrains.jps.model.library.impl.JpsLibraryImpl; +import org.jetbrains.jps.model.library.impl.JpsLibraryCollectionImpl; import org.jetbrains.jps.model.library.impl.JpsLibraryKind; import org.jetbrains.jps.model.module.*; @@ -18,8 +21,8 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase> TYPED_DATA_KIND = new JpsTypedDataKind>(); 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 static final JpsElementKind DEPENDENCIES_LIST_KIND = new JpsElementKindBase("dependencies"); + private final JpsLibraryCollection myLibraryCollection; public JpsModuleImpl(JpsModuleType type, @NotNull String name) { @@ -28,13 +31,14 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase type, @NotNull String name) { - return addModuleLibrary(new JpsLibraryImpl(name, type)); + return myLibraryCollection.addLibrary(type, name); + } + + @Override + public void addModuleLibrary(final @NotNull JpsLibrary library) { + myLibraryCollection.addLibrary(library); } @NotNull @Override - public JpsLibrary addModuleLibrary(final @NotNull JpsLibrary library) { - return myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).addChild(library); + public JpsLibraryCollection getLibraryCollection() { + return myLibraryCollection; } } diff --git a/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsLibraryTest.java b/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsLibraryTest.java index 7410eec8f26e..e279eb1d114a 100644 --- a/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsLibraryTest.java +++ b/jps/model-impl/testSrc/org/jetbrains/jps/model/JpsLibraryTest.java @@ -1,9 +1,7 @@ package org.jetbrains.jps.model; import org.jetbrains.jps.model.java.JpsJavaLibraryType; -import org.jetbrains.jps.model.library.JpsLibrary; -import org.jetbrains.jps.model.library.JpsLibraryReference; -import org.jetbrains.jps.model.library.JpsLibraryRootType; +import org.jetbrains.jps.model.library.*; /** * @author nik @@ -11,20 +9,20 @@ import org.jetbrains.jps.model.library.JpsLibraryRootType; public class JpsLibraryTest extends JpsModelTestCase { public void testAddRoot() { final JpsLibrary library = myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "a"); - library.addUrl("file://my-url", JpsLibraryRootType.COMPILED); - assertEquals("file://my-url", assertOneElement(library.getUrls(JpsLibraryRootType.COMPILED))); + library.addRoot("file://my-url", JpsOrderRootType.COMPILED); + assertEquals("file://my-url", assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl()); } public void testModifiableCopy() { myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "a"); final JpsModel modifiableModel = myModel.createModifiableModel(new TestJpsEventDispatcher()); - final JpsLibrary modifiable = assertOneElement(modifiableModel.getProject().getLibraries()); - modifiable.addUrl("file://my-url", JpsLibraryRootType.COMPILED); + final JpsLibrary modifiable = assertOneElement(modifiableModel.getProject().getLibraryCollection().getLibraries()); + modifiable.addRoot("file://my-url", JpsOrderRootType.COMPILED); modifiableModel.commit(); - final JpsLibrary library = assertOneElement(myModel.getProject().getLibraries()); - assertEquals("file://my-url", assertOneElement(library.getUrls(JpsLibraryRootType.COMPILED))); + final JpsLibrary library = assertOneElement(myModel.getProject().getLibraryCollection().getLibraries()); + assertEquals("file://my-url", assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl()); } public void testCreateReferenceByLibrary() { 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 index ee53d55a93a9..a6e4b81e40f6 100644 --- a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsLibraryTableLoader.java +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsLibraryTableLoader.java @@ -5,10 +5,7 @@ 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.model.library.*; import org.jetbrains.jps.service.JpsServiceManager; import java.util.HashMap; @@ -55,9 +52,15 @@ public class JpsLibraryTableLoader { 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)); + JpsLibraryRoot.InclusionOptions options; + if (jarDirectories.get(rootType).contains(url)) { + final boolean recursive = recursiveJarDirectories.get(rootType).contains(url); + options = recursive ? JpsLibraryRoot.InclusionOptions.ARCHIVES_UNDER_ROOT_RECURSIVELY : JpsLibraryRoot.InclusionOptions.ARCHIVES_UNDER_ROOT; + } + else { + options = JpsLibraryRoot.InclusionOptions.ROOT_ITSELF; + } + library.addRoot(url, rootType, options); } } } 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 index 9e68ed669178..45751864903d 100644 --- a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java @@ -103,7 +103,7 @@ public class JpsProjectLoader { final ArrayList libraries = new ArrayList(); JpsLibraryTableLoader.loadLibraries(libraryTableElement, libraries); for (JpsLibrary library : libraries) { - myProject.addLibrary(library); + myProject.getLibraryCollection().addLibrary(library); } } 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 index 20087a1e0326..bb7a5a0970b4 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModuleSerializationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModuleSerializationTest.java @@ -15,7 +15,7 @@ public class JpsModuleSerializationTest extends JpsModelTestCase { loadProject("iprProject/iprProject.ipr"); final JpsModule module = assertOneElement(myModel.getProject().getModules()); assertEquals("iprProject", module.getName()); - final JpsLibrary library = assertOneElement(myModel.getProject().getLibraries()); + final JpsLibrary library = assertOneElement(myModel.getProject().getLibraryCollection().getLibraries()); assertEquals("junit", library.getName()); } diff --git a/platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryDelegate.java b/platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryDelegate.java new file mode 100644 index 000000000000..eb95c0e11eaa --- /dev/null +++ b/platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryDelegate.java @@ -0,0 +1,209 @@ +/* + * 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.project.model.impl.library; + +import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.roots.RootProvider; +import com.intellij.openapi.roots.impl.RootModelImpl; +import com.intellij.openapi.roots.impl.RootProviderBaseImpl; +import com.intellij.openapi.roots.impl.libraries.JarDirectories; +import com.intellij.openapi.roots.impl.libraries.LibraryEx; +import com.intellij.openapi.roots.impl.libraries.LibraryImpl; +import com.intellij.openapi.roots.libraries.Library; +import com.intellij.openapi.roots.libraries.LibraryProperties; +import com.intellij.openapi.roots.libraries.LibraryTable; +import com.intellij.openapi.roots.libraries.PersistentLibraryKind; +import com.intellij.openapi.util.InvalidDataException; +import com.intellij.openapi.util.WriteExternalException; +import com.intellij.openapi.vfs.VfsUtilCore; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.openapi.vfs.pointers.VirtualFilePointer; +import com.intellij.openapi.vfs.pointers.VirtualFilePointerContainer; +import com.intellij.util.ArrayUtil; +import com.intellij.util.SmartList; +import org.jdom.Element; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryRoot; +import org.jetbrains.jps.model.library.JpsOrderRootType; + +import java.util.*; + +/** + * @author nik + */ +public class JpsLibraryDelegate implements LibraryEx { + private JpsLibrary myJpsLibrary; + private JpsLibraryTableImpl myLibraryTable; + private Map myRoots; + private RootProviderBaseImpl myRootProvider = new MyRootProvider(); + + public JpsLibraryDelegate(JpsLibrary library, JpsLibraryTableImpl table) { + myJpsLibrary = library; + myLibraryTable = table; + myRoots = new HashMap(); + } + + @Override + public String getName() { + return myJpsLibrary.getName(); + } + + @Override + public PersistentLibraryKind getKind() { + return null; + } + + @Override + public LibraryProperties getProperties() { + return null; + } + + @NotNull + @Override + public String[] getUrls(@NotNull OrderRootType rootType) { + final VirtualFilePointerContainer container = myRoots.get(rootType); + if (container == null) return ArrayUtil.EMPTY_STRING_ARRAY; + return container.getUrls(); + } + + @NotNull + @Override + public VirtualFile[] getFiles(@NotNull OrderRootType rootType) { + final VirtualFilePointerContainer container = myRoots.get(rootType); + if (container == null) return VirtualFile.EMPTY_ARRAY; + final List expanded = new ArrayList(); + for (JpsLibraryRoot root : myJpsLibrary.getRoots(getJpsRootType(rootType))) { + final VirtualFilePointer pointer = container.findByUrl(root.getUrl()); + if (pointer == null) continue; + VirtualFile file = pointer.getFile(); + if (file == null) continue; + + if (file.isDirectory() && root.getInclusionOptions() != JpsLibraryRoot.InclusionOptions.ROOT_ITSELF) { + LibraryImpl.collectJarFiles(file, expanded, root.getInclusionOptions() == JpsLibraryRoot.InclusionOptions.ARCHIVES_UNDER_ROOT_RECURSIVELY); + continue; + } + expanded.add(file); + } + return VfsUtilCore.toVirtualFileArray(expanded); + } + + @Override + public List getInvalidRootUrls(OrderRootType type) { + final VirtualFilePointerContainer container = myRoots.get(type); + if (container == null) return Collections.emptyList(); + final List pointers = container.getList(); + List invalidPaths = null; + for (VirtualFilePointer pointer : pointers) { + if (!pointer.isValid()) { + if (invalidPaths == null) { + invalidPaths = new SmartList(); + } + invalidPaths.add(pointer.getUrl()); + } + } + return invalidPaths == null ? Collections.emptyList() : invalidPaths; + } + + @Override + public boolean isDisposed() { + return false; + } + + @Override + public LibraryTable getTable() { + return myLibraryTable; + } + + @NotNull + @Override + public RootProvider getRootProvider() { + return myRootProvider; + } + + @Override + public void dispose() { + } + + @Override + public Library cloneLibrary(RootModelImpl rootModel) { + throw new UnsupportedOperationException("'cloneLibrary' not implemented in " + getClass().getName()); + } + + @NotNull + @Override + public ModifiableModel getModifiableModel() { + throw new UnsupportedOperationException("'getModifiableModel' not implemented in " + getClass().getName()); + } + + @Override + public void readExternal(Element element) throws InvalidDataException { + throw new UnsupportedOperationException(); + } + + @Override + public void writeExternal(Element element) throws WriteExternalException { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isJarDirectory(@NotNull String url) { + return isJarDirectory(url, JarDirectories.DEFAULT_JAR_DIRECTORY_TYPE); + } + + @Override + public boolean isJarDirectory(@NotNull String url, @NotNull OrderRootType rootType) { + for (JpsLibraryRoot root : myJpsLibrary.getRoots(getJpsRootType(rootType))) { + if (url.equals(root.getUrl()) && root.getInclusionOptions() != JpsLibraryRoot.InclusionOptions.ROOT_ITSELF) { + return true; + } + } + return false; + } + + @Override + public boolean isValid(@NotNull String url, @NotNull OrderRootType rootType) { + final VirtualFilePointerContainer container = myRoots.get(rootType); + if (container == null) return false; + final VirtualFilePointer fp = container.findByUrl(url); + return fp != null && fp.isValid(); + } + + private static JpsOrderRootType getJpsRootType(OrderRootType type) { + if (type == OrderRootType.CLASSES) return JpsOrderRootType.COMPILED; + if (type == OrderRootType.SOURCES) return JpsOrderRootType.SOURCES; + if (type == OrderRootType.DOCUMENTATION) return JpsOrderRootType.DOCUMENTATION; + return JpsOrderRootType.COMPILED; + } + + private class MyRootProvider extends RootProviderBaseImpl { + @NotNull + @Override + public String[] getUrls(@NotNull OrderRootType rootType) { + Set originalUrls = new LinkedHashSet(Arrays.asList(JpsLibraryDelegate.this.getUrls(rootType))); + for (VirtualFile file : getFiles(rootType)) { // Add those expanded with jar directories. + originalUrls.add(file.getUrl()); + } + return ArrayUtil.toStringArray(originalUrls); + } + + @NotNull + @Override + public VirtualFile[] getFiles(@NotNull OrderRootType rootType) { + return JpsLibraryDelegate.this.getFiles(rootType); + } + } +} diff --git a/platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryTableImpl.java b/platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryTableImpl.java new file mode 100644 index 000000000000..2819a876ee75 --- /dev/null +++ b/platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryTableImpl.java @@ -0,0 +1,189 @@ +/* + * 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.project.model.impl.library; + +import com.intellij.openapi.Disposable; +import com.intellij.openapi.roots.impl.libraries.LibraryTableBase; +import com.intellij.openapi.roots.libraries.Library; +import com.intellij.openapi.roots.libraries.LibraryTable; +import com.intellij.openapi.roots.libraries.LibraryTablePresentation; +import com.intellij.openapi.roots.libraries.PersistentLibraryKind; +import com.intellij.openapi.util.Disposer; +import com.intellij.util.EventDispatcher; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jps.model.library.JpsLibrary; +import org.jetbrains.jps.model.library.JpsLibraryCollection; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +/** + * @author nik + */ +public class JpsLibraryTableImpl implements LibraryTable, Disposable { + private JpsLibrariesModel myModel; + private final EventDispatcher myDispatcher = EventDispatcher.create(Listener.class); + private String myTableLevel; + private LibraryTablePresentation myPresentation; + + public JpsLibraryTableImpl(JpsLibraryCollection libraryCollection, String level) { + myTableLevel = level; + myModel = new JpsLibrariesModel(libraryCollection); + } + + @NotNull + @Override + public Library[] getLibraries() { + return myModel.getLibraries(); + } + + @NotNull + @Override + public Iterator getLibraryIterator() { + return myModel.getLibraryIterator(); + } + + @Override + public Library getLibraryByName(@NotNull String name) { + return myModel.getLibraryByName(name); + } + + @Override + public void addListener(Listener listener) { + myDispatcher.addListener(listener); + } + + @Override + public void addListener(Listener listener, Disposable parentDisposable) { + myDispatcher.addListener(listener, parentDisposable); + } + + @Override + public void removeListener(Listener listener) { + myDispatcher.removeListener(listener); + } + + @Override + public Library createLibrary() { + return createLibrary(null); + } + + @Override + public Library createLibrary(@NonNls String name) { + final ModifiableModel model = getModifiableModel(); + final Library library = model.createLibrary(name); + model.commit(); + return library; + } + + @Override + public void removeLibrary(@NotNull Library library) { + final ModifiableModel model = getModifiableModel(); + model.removeLibrary(library); + model.commit(); + } + + @Override + public void dispose() { + for (Library library : getLibraries()) { + Disposer.dispose(library); + } + } + + @Override + public ModifiableModel getModifiableModel() { + return new JpsLibrariesModel(myModel.myJpsLibraries); + } + + @Override + public boolean isEditable() { + return true; + } + + @Override + public String getTableLevel() { + return myTableLevel; + } + + @Override + public LibraryTablePresentation getPresentation() { + return myPresentation; + } + + private class JpsLibrariesModel implements LibraryTableBase.ModifiableModelEx { + private JpsLibraryCollection myJpsLibraries; + private List myLibraries; + + private JpsLibrariesModel(JpsLibraryCollection libraryCollection) { + myLibraries = new ArrayList(); + myJpsLibraries = libraryCollection; + for (JpsLibrary library : libraryCollection.getLibraries()) { + myLibraries.add(new JpsLibraryDelegate(library, JpsLibraryTableImpl.this)); + } + } + + @Override + public Library createLibrary(String name) { + return createLibrary(name, null); + } + + @Override + public Library createLibrary(String name, @Nullable PersistentLibraryKind type) { + throw new UnsupportedOperationException("'createLibrary' not implemented in " + getClass().getName()); + } + + @NotNull + @Override + public Iterator getLibraryIterator() { + return Collections.unmodifiableList(myLibraries).iterator(); + } + + @Override + public void removeLibrary(@NotNull Library library) { + throw new UnsupportedOperationException(); + } + + @NotNull + @Override + public Library[] getLibraries() { + return myLibraries.toArray(new Library[myLibraries.size()]); + } + + @Override + public Library getLibraryByName(@NotNull String name) { + for (JpsLibraryDelegate library : myLibraries) { + if (name.equals(library.getName())) { + return library; + } + } + return null; + } + + @Override + public void commit() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isChanged() { + return false; + } + } +} diff --git a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsContentEntry.java b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsContentEntry.java index 38343a8bb911..db1f6462eabc 100644 --- a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsContentEntry.java +++ b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsContentEntry.java @@ -31,6 +31,8 @@ import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager; import com.intellij.project.model.impl.module.JpsRootModel; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jps.model.java.JavaSourceRootProperties; +import org.jetbrains.jps.model.java.JavaSourceRootType; import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleSourceRoot; @@ -130,47 +132,80 @@ public class JpsContentEntry implements ContentEntry, Disposable { @Override public SourceFolder addSourceFolder(@NotNull VirtualFile file, boolean isTestSource) { - throw new UnsupportedOperationException("'addSourceFolder' not implemented in " + getClass().getName()); + return addSourceFolder(file, isTestSource, ""); } @Override public SourceFolder addSourceFolder(@NotNull VirtualFile file, boolean isTestSource, @NotNull String packagePrefix) { - throw new UnsupportedOperationException("'addSourceFolder' not implemented in " + getClass().getName()); + return addSourceFolder(file.getUrl(), isTestSource, packagePrefix); + } + + private SourceFolder addSourceFolder(final String url, boolean isTestSource, String packagePrefix) { + final JavaSourceRootType rootType = isTestSource ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE; + final JpsModuleSourceRoot sourceRoot = myModule.addSourceRoot(rootType, url, new JavaSourceRootProperties(packagePrefix)); + final JpsSourceFolder sourceFolder = new JpsSourceFolder(sourceRoot, this); + mySourceFolders.add(sourceFolder); + return sourceFolder; } @Override public SourceFolder addSourceFolder(@NotNull String url, boolean isTestSource) { - throw new UnsupportedOperationException("'addSourceFolder' not implemented in " + getClass().getName()); + return addSourceFolder(url, isTestSource, ""); } @Override public void removeSourceFolder(@NotNull SourceFolder sourceFolder) { - throw new UnsupportedOperationException(); + final JpsSourceFolder folder = (JpsSourceFolder)sourceFolder; + mySourceFolders.remove(folder); + myModule.removeSourceRoot(folder.getSourceRoot().getRootType(), folder.getSourceRoot().getUrl()); + Disposer.dispose(folder); } @Override public void clearSourceFolders() { - throw new UnsupportedOperationException(); + List toRemove = new ArrayList(); + for (JpsSourceFolder folder : mySourceFolders) { + toRemove.add(folder.getSourceRoot()); + Disposer.dispose(folder); + } + mySourceFolders.clear(); + for (JpsModuleSourceRoot root : toRemove) { + myModule.removeSourceRoot(root.getRootType(), root.getUrl()); + } } @Override public ExcludeFolder addExcludeFolder(@NotNull VirtualFile file) { - throw new UnsupportedOperationException("'addExcludeFolder' not implemented in " + getClass().getName()); + return addExcludeFolder(file.getUrl()); } @Override public ExcludeFolder addExcludeFolder(@NotNull String url) { - throw new UnsupportedOperationException("'addExcludeFolder' not implemented in " + getClass().getName()); + final JpsExcludeFolder folder = new JpsExcludeFolder(url, this); + myModule.getExcludeRootsList().addUrl(url); + myExcludeFolders.add(folder); + return folder; } @Override public void removeExcludeFolder(@NotNull ExcludeFolder excludeFolder) { - throw new UnsupportedOperationException(); + JpsExcludeFolder folder = (JpsExcludeFolder)excludeFolder; + myExcludeFolders.remove(folder); + myModule.getExcludeRootsList().removeUrl(folder.getUrl()); + Disposer.dispose(folder); } @Override public void clearExcludeFolders() { - throw new UnsupportedOperationException(); + List toRemove = new ArrayList(); + for (JpsExcludeFolder folder : myExcludeFolders) { + toRemove.add(folder.getUrl()); + Disposer.dispose(folder); + } + myExcludeFolders.clear(); + for (String url : toRemove) { + myModule.getExcludeRootsList().removeUrl(url); + } } @Override diff --git a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsSourceFolder.java b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsSourceFolder.java index 219b0f8bdd12..41127ac8b250 100644 --- a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsSourceFolder.java +++ b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsSourceFolder.java @@ -32,6 +32,10 @@ public class JpsSourceFolder extends JpsContentFolderBase implements SourceFolde mySourceRoot = sourceRoot; } + public JpsModuleSourceRoot getSourceRoot() { + return mySourceRoot; + } + @Override public boolean isTestSource() { return mySourceRoot.getRootType() == JavaSourceRootType.TEST_SOURCE; diff --git a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsExportableOrderEntry.java b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsExportableOrderEntry.java index 693899a33517..d04b8c19bab1 100644 --- a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsExportableOrderEntry.java +++ b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsExportableOrderEntry.java @@ -56,7 +56,7 @@ public abstract class JpsExportableOrderEntry ex @Override public void setScope(@NotNull DependencyScope scope) { - JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(myDependencyElement) - .setScope(JpsJavaDependencyScope.valueOf(scope.name())); + final JpsJavaDependencyExtension extension = JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(myDependencyElement); + extension.setScope(JpsJavaDependencyScope.valueOf(scope.name())); } } diff --git a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsModuleOrderEntry.java b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsModuleOrderEntry.java index 3617589faf25..48b5bca5fa40 100644 --- a/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsModuleOrderEntry.java +++ b/platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsModuleOrderEntry.java @@ -18,10 +18,13 @@ package com.intellij.project.model.impl.module.dependencies; import com.intellij.openapi.module.Module; import com.intellij.openapi.roots.ModuleOrderEntry; import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.roots.OrderRootsEnumerator; import com.intellij.openapi.roots.RootPolicy; +import com.intellij.openapi.roots.impl.ModuleRootManagerImpl; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.project.model.JpsModelManager; import com.intellij.project.model.impl.module.JpsRootModel; +import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.model.module.JpsModule; @@ -53,15 +56,23 @@ public class JpsModuleOrderEntry extends JpsExportableOrderEntry