android/src/com/android/tools/idea/npw/ModuleListModel.java - platform/tools/adt/idea - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * 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.android.tools.idea.npw;

 import com.android.annotations.VisibleForTesting;
 import com.android.tools.idea.gradle.project.ModuleToImport;
 import com.android.tools.idea.gradle.util.GradleUtil;
 import com.google.common.base.Function;
 import com.google.common.base.Functions;
 import com.google.common.base.Objects;
 import com.google.common.base.Predicate;
 import com.google.common.collect.*;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.MessageType;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.util.Collection;
 import java.util.Map;
 import java.util.Queue;
 import java.util.Set;

 /**
  * Manages list of modules.
  */
 public final class ModuleListModel {
   @Nullable private final Project myProject;
   private Map<ModuleToImport, ModuleValidationState> myModules;
   private Multimap<ModuleToImport, ModuleToImport> myRequiredModules;
   @Nullable private VirtualFile mySelectedDirectory;
   private Map<ModuleToImport, String> myNameOverrides = Maps.newHashMap();
   private ModuleToImport myPrimaryModule;
   private Map<ModuleToImport, Boolean> myExplicitSelection = Maps.newHashMap();

   public ModuleListModel(@Nullable Project project) {
     myProject = project;
   }

   @Nullable
   private static ModuleToImport findPrimaryModule(@Nullable VirtualFile directory, @NotNull Iterable<ModuleToImport> modules) {
     if (directory == null) {
       return null;
     }
     for (ModuleToImport module : modules) {
       if (Objects.equal(module.location, directory)) {
         return module;
       }
     }
     return null;
   }

   private static boolean isValidModuleName(String moduleName) {
     if (StringUtil.isEmpty(moduleName)) {
       return false;
     }
     int previousSegmentStart = 0;
     for (int segmentSeparator = moduleName.indexOf(":", previousSegmentStart);
          segmentSeparator >= 0;
          segmentSeparator = moduleName.indexOf(":", previousSegmentStart)) {
       if (!isValidPathSegment(moduleName, previousSegmentStart, segmentSeparator)) {
         return false;
       }
       previousSegmentStart = segmentSeparator + 1;
     }
     return isValidPathSegment(moduleName, previousSegmentStart, moduleName.length());
   }

   private static boolean isValidPathSegment(String string, int segmentStart, int segmentEnd) {
     if (segmentEnd == segmentStart) {
       return segmentStart == 0; // Only allowed at string start to allow for absolute paths
     }
     String segment = string.substring(segmentStart, segmentEnd);
     return !StringUtil.isEmpty(segment) && GradleUtil.isValidGradlePath(segment) < 0;
   }

   private static String getNameErrorMessage(String moduleName) {
     if (StringUtil.isEmptyOrSpaces(moduleName)) {
       return "Module name is empty";
     }
     else {
       return "Module name is not valid";
     }
   }

   private Multimap<ModuleToImport, ModuleToImport> computeRequiredModules(Set<ModuleToImport> modules) {
     Map<String, ModuleToImport> namesToModules = Maps.newHashMapWithExpectedSize(modules.size());
     // We only care about modules we are actually going to import.
     for (ModuleToImport module : modules) {
       namesToModules.put(module.name, module);
     }
     Multimap<ModuleToImport, ModuleToImport> requiredModules = LinkedListMultimap.create();
     Queue<ModuleToImport> queue = Lists.newLinkedList();

     for (ModuleToImport module : modules) {
       if (Objects.equal(module, myPrimaryModule) || !isUnselected(module, false)) {
         queue.add(module);
       }
     }
     while (!queue.isEmpty()) {
       ModuleToImport moduleToImport = queue.remove();
       for (ModuleToImport dep : Iterables.transform(moduleToImport.getDependencies(), Functions.forMap(namesToModules, null))) {
         if (dep != null) {
           if (!requiredModules.containsKey(dep)) {
             queue.add(dep);
           }
           requiredModules.put(dep, moduleToImport);
         }
       }
     }
     return requiredModules;
   }

   private boolean isUnselected(ModuleToImport module, boolean isSelected) {
     if (module.location == null) {
       return true;
     }
     else if (Objects.equal(myPrimaryModule, module)) {
       return false;
     }
     else if (myModules.get(module) == ModuleValidationState.ALREADY_EXISTS) {
       return !Objects.equal(true, myExplicitSelection.get(module));
     }
     else {
       return !isSelected && isExplicitlyUnselected(module);
     }
   }

   private ModuleValidationState validateModule(ModuleToImport module) {
     VirtualFile location = module.location;
     if (location == null || !location.exists()) {
       return ModuleValidationState.NOT_FOUND;
     }
     String moduleName = getModuleName(module);
     if (!isValidModuleName(moduleName)) {
       return ModuleValidationState.INVALID_NAME;
     }
     else if (GradleUtil.hasModule(myProject, moduleName, true)) {
       return ModuleValidationState.ALREADY_EXISTS;
     }
     else {
       return ModuleValidationState.OK;
     }
   }

   public void setContents(@Nullable VirtualFile selectedDirectory, @NotNull Iterable<ModuleToImport> modules) {
     mySelectedDirectory = selectedDirectory;
     myPrimaryModule = findPrimaryModule(selectedDirectory, modules);
     revalidate(modules);
   }

   private void checkForDuplicateNames() {
     Collection<ModuleToImport> modules = getSelectedModules();
     ImmutableMultiset<String> names = ImmutableMultiset.copyOf(Iterables.transform(modules, new Function<ModuleToImport, String>() {
       @Override
       public String apply(@Nullable ModuleToImport input) {
         return input == null ? null : getModuleName(input);
       }
     }));
     for (ModuleToImport module : modules) {
       ModuleValidationState state = myModules.get(module);
       if (state == ModuleValidationState.OK) {
         if (names.count(getModuleName(module)) > 1) {
           myModules.put(module, ModuleValidationState.DUPLICATE_MODULE_NAME);
         }
       }
     }
   }

   public Set<ModuleToImport> getSelectedModules() {
     return ImmutableSet.copyOf(Iterables.filter(myModules.keySet(), new Predicate<ModuleToImport>() {
       @Override
       public boolean apply(@Nullable ModuleToImport input) {
         assert input != null;
         return isSelected(input);
       }
     }));
   }

   public boolean hasPrimary() {
     return myPrimaryModule != null;
   }

   public String getModuleName(ModuleToImport module) {
     if (myNameOverrides.containsKey(module) && !isRequiredModule(module)) {
       return myNameOverrides.get(module);
     }
     return module.name;
   }

   @VisibleForTesting
   public ModuleValidationState getModuleState(ModuleToImport module) {
     if (module == null) {
       return ModuleValidationState.NULL;
     }
     ModuleValidationState state = myModules.get(module);
     if (state == ModuleValidationState.OK && isRequiredModule(module)) {
       return ModuleValidationState.REQUIRED;
     }
     else {
       return state;
     }
   }

   private boolean isRequiredModule(ModuleToImport module) {
     return myRequiredModules.containsKey(module);
   }

   private Map<ModuleToImport, ModuleValidationState> validateModules(Iterable<ModuleToImport> modules) {
     Map<ModuleToImport, ModuleValidationState> result = Maps.newHashMap();
     for (ModuleToImport module : modules) {
       result.put(module, validateModule(module));
     }
     return result;
   }

   public void setSelected(ModuleToImport module, boolean isSelected) {
     myExplicitSelection.put(module, isSelected);
     revalidate(myModules.keySet());
   }

   private void revalidate(Iterable<ModuleToImport> modules) {
     myModules = validateModules(modules);
     myRequiredModules = computeRequiredModules(myModules.keySet());
     for (ModuleToImport module : myRequiredModules.keySet()) {
       myNameOverrides.remove(module);
     }
     checkForDuplicateNames();
   }

   public void setModuleName(ModuleToImport module, @Nullable String newName) {
     if (!isExplicitlyUnselected(module)) {
       if (newName == null) {
         myNameOverrides.remove(module);
       }
       else {
         myNameOverrides.put(module, newName);
       }
       revalidate(myModules.keySet());
     }
   }

   private boolean isExplicitlyUnselected(ModuleToImport module) {
     return Objects.equal(false, myExplicitSelection.get(module));
   }

   @Nullable
   public MessageType getStatusSeverity(ModuleToImport module) {
     ModuleValidationState state = getModuleState(module);
     switch (state) {
       case OK:
       case NULL:
         return null;
       case NOT_FOUND:
       case DUPLICATE_MODULE_NAME:
       case INVALID_NAME:
         return MessageType.ERROR;
       case ALREADY_EXISTS:
         return getSelectedModules().contains(module) ? MessageType.ERROR : MessageType.WARNING;
       case REQUIRED:
         return MessageType.INFO;
     }
     throw new IllegalArgumentException(state.name());
   }

   @Nullable
   public String getStatusDescription(@NotNull ModuleToImport module) {
     ModuleValidationState state = getModuleState(module);
     switch (state) {
       case OK:
       case NULL:
         return null;
       case NOT_FOUND:
         return "Module sources not found";
       case ALREADY_EXISTS:
         if (isSelected(module) && isRequiredModule(module)) {
           return "Cannot rename module required by another";
         }
         return "Project already contains module with this name";
       case DUPLICATE_MODULE_NAME:
         return "More then one module with this name is selected";
       case REQUIRED:
         Iterable<String> requiredBy = Iterables.transform(myRequiredModules.get(module), new Function<ModuleToImport, String>() {
           @Override
           public String apply(ModuleToImport input) {
             return "'" + getModuleName(input) + "'";
           }
         });
         return ImportUIUtil.formatElementListString(requiredBy, "Required by module %s", "Required by modules %s and %s",
                                                     "Required by modules %s and %d more");
       case INVALID_NAME:
         return getNameErrorMessage(getModuleName(module));
     }
     throw new IllegalStateException(state.name());
   }

   @Nullable
   public ModuleToImport getPrimary() {
     return myPrimaryModule;
   }

   @Nullable
   public VirtualFile getCurrentPath() {
     return mySelectedDirectory;
   }

   public Collection<ModuleToImport> getAllModules() {
     return ImmutableList.copyOf(myModules.keySet());
   }

   public boolean isSelected(@NotNull ModuleToImport module) {
     return !isUnselected(module, isRequiredModule(module));
   }

   public boolean canToggleModuleSelection(ModuleToImport module) {
     ModuleValidationState state = getModuleState(module);
     return state != ModuleValidationState.NOT_FOUND && !isRequiredModule(module);
   }

   public boolean canRename(ModuleToImport module) {
     return !isRequiredModule(module) && isSelected(module);
   }

   @VisibleForTesting
   public enum ModuleValidationState {
     OK, NULL, NOT_FOUND, ALREADY_EXISTS, REQUIRED, DUPLICATE_MODULE_NAME, INVALID_NAME
   }
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* 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.android.tools.idea.npw;

	import com.android.annotations.VisibleForTesting;
	import com.android.tools.idea.gradle.project.ModuleToImport;
	import com.android.tools.idea.gradle.util.GradleUtil;
	import com.google.common.base.Function;
	import com.google.common.base.Functions;
	import com.google.common.base.Objects;
	import com.google.common.base.Predicate;
	import com.google.common.collect.*;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.ui.MessageType;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.openapi.vfs.VirtualFile;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.util.Collection;
	import java.util.Map;
	import java.util.Queue;
	import java.util.Set;

	/**
	* Manages list of modules.
	*/
	public final class ModuleListModel {
	@Nullable private final Project myProject;
	private Map<ModuleToImport, ModuleValidationState> myModules;
	private Multimap<ModuleToImport, ModuleToImport> myRequiredModules;
	@Nullable private VirtualFile mySelectedDirectory;
	private Map<ModuleToImport, String> myNameOverrides = Maps.newHashMap();
	private ModuleToImport myPrimaryModule;
	private Map<ModuleToImport, Boolean> myExplicitSelection = Maps.newHashMap();

	public ModuleListModel(@Nullable Project project) {
	myProject = project;
	}

	@Nullable
	private static ModuleToImport findPrimaryModule(@Nullable VirtualFile directory, @NotNull Iterable<ModuleToImport> modules) {
	if (directory == null) {
	return null;
	}
	for (ModuleToImport module : modules) {
	if (Objects.equal(module.location, directory)) {
	return module;
	}
	}
	return null;
	}

	private static boolean isValidModuleName(String moduleName) {
	if (StringUtil.isEmpty(moduleName)) {
	return false;
	}
	int previousSegmentStart = 0;
	for (int segmentSeparator = moduleName.indexOf(":", previousSegmentStart);
	segmentSeparator >= 0;
	segmentSeparator = moduleName.indexOf(":", previousSegmentStart)) {
	if (!isValidPathSegment(moduleName, previousSegmentStart, segmentSeparator)) {
	return false;
	}
	previousSegmentStart = segmentSeparator + 1;
	}
	return isValidPathSegment(moduleName, previousSegmentStart, moduleName.length());
	}

	private static boolean isValidPathSegment(String string, int segmentStart, int segmentEnd) {
	if (segmentEnd == segmentStart) {
	return segmentStart == 0; // Only allowed at string start to allow for absolute paths
	}
	String segment = string.substring(segmentStart, segmentEnd);
	return !StringUtil.isEmpty(segment) && GradleUtil.isValidGradlePath(segment) < 0;
	}

	private static String getNameErrorMessage(String moduleName) {
	if (StringUtil.isEmptyOrSpaces(moduleName)) {
	return "Module name is empty";
	}
	else {
	return "Module name is not valid";
	}
	}

	private Multimap<ModuleToImport, ModuleToImport> computeRequiredModules(Set<ModuleToImport> modules) {
	Map<String, ModuleToImport> namesToModules = Maps.newHashMapWithExpectedSize(modules.size());
	// We only care about modules we are actually going to import.
	for (ModuleToImport module : modules) {
	namesToModules.put(module.name, module);
	}
	Multimap<ModuleToImport, ModuleToImport> requiredModules = LinkedListMultimap.create();
	Queue<ModuleToImport> queue = Lists.newLinkedList();

	for (ModuleToImport module : modules) {
	if (Objects.equal(module, myPrimaryModule) \|\| !isUnselected(module, false)) {
	queue.add(module);
	}
	}
	while (!queue.isEmpty()) {
	ModuleToImport moduleToImport = queue.remove();
	for (ModuleToImport dep : Iterables.transform(moduleToImport.getDependencies(), Functions.forMap(namesToModules, null))) {
	if (dep != null) {
	if (!requiredModules.containsKey(dep)) {
	queue.add(dep);
	}
	requiredModules.put(dep, moduleToImport);
	}
	}
	}
	return requiredModules;
	}

	private boolean isUnselected(ModuleToImport module, boolean isSelected) {
	if (module.location == null) {
	return true;
	}
	else if (Objects.equal(myPrimaryModule, module)) {
	return false;
	}
	else if (myModules.get(module) == ModuleValidationState.ALREADY_EXISTS) {
	return !Objects.equal(true, myExplicitSelection.get(module));
	}
	else {
	return !isSelected && isExplicitlyUnselected(module);
	}
	}

	private ModuleValidationState validateModule(ModuleToImport module) {
	VirtualFile location = module.location;
	if (location == null \|\| !location.exists()) {
	return ModuleValidationState.NOT_FOUND;
	}
	String moduleName = getModuleName(module);
	if (!isValidModuleName(moduleName)) {
	return ModuleValidationState.INVALID_NAME;
	}
	else if (GradleUtil.hasModule(myProject, moduleName, true)) {
	return ModuleValidationState.ALREADY_EXISTS;
	}
	else {
	return ModuleValidationState.OK;
	}
	}

	public void setContents(@Nullable VirtualFile selectedDirectory, @NotNull Iterable<ModuleToImport> modules) {
	mySelectedDirectory = selectedDirectory;
	myPrimaryModule = findPrimaryModule(selectedDirectory, modules);
	revalidate(modules);
	}

	private void checkForDuplicateNames() {
	Collection<ModuleToImport> modules = getSelectedModules();
	ImmutableMultiset<String> names = ImmutableMultiset.copyOf(Iterables.transform(modules, new Function<ModuleToImport, String>() {
	@Override
	public String apply(@Nullable ModuleToImport input) {
	return input == null ? null : getModuleName(input);
	}
	}));
	for (ModuleToImport module : modules) {
	ModuleValidationState state = myModules.get(module);
	if (state == ModuleValidationState.OK) {
	if (names.count(getModuleName(module)) > 1) {
	myModules.put(module, ModuleValidationState.DUPLICATE_MODULE_NAME);
	}
	}
	}
	}

	public Set<ModuleToImport> getSelectedModules() {
	return ImmutableSet.copyOf(Iterables.filter(myModules.keySet(), new Predicate<ModuleToImport>() {
	@Override
	public boolean apply(@Nullable ModuleToImport input) {
	assert input != null;
	return isSelected(input);
	}
	}));
	}

	public boolean hasPrimary() {
	return myPrimaryModule != null;
	}

	public String getModuleName(ModuleToImport module) {
	if (myNameOverrides.containsKey(module) && !isRequiredModule(module)) {
	return myNameOverrides.get(module);
	}
	return module.name;
	}

	@VisibleForTesting
	public ModuleValidationState getModuleState(ModuleToImport module) {
	if (module == null) {
	return ModuleValidationState.NULL;
	}
	ModuleValidationState state = myModules.get(module);
	if (state == ModuleValidationState.OK && isRequiredModule(module)) {
	return ModuleValidationState.REQUIRED;
	}
	else {
	return state;
	}
	}

	private boolean isRequiredModule(ModuleToImport module) {
	return myRequiredModules.containsKey(module);
	}

	private Map<ModuleToImport, ModuleValidationState> validateModules(Iterable<ModuleToImport> modules) {
	Map<ModuleToImport, ModuleValidationState> result = Maps.newHashMap();
	for (ModuleToImport module : modules) {
	result.put(module, validateModule(module));
	}
	return result;
	}

	public void setSelected(ModuleToImport module, boolean isSelected) {
	myExplicitSelection.put(module, isSelected);
	revalidate(myModules.keySet());
	}

	private void revalidate(Iterable<ModuleToImport> modules) {
	myModules = validateModules(modules);
	myRequiredModules = computeRequiredModules(myModules.keySet());
	for (ModuleToImport module : myRequiredModules.keySet()) {
	myNameOverrides.remove(module);
	}
	checkForDuplicateNames();
	}

	public void setModuleName(ModuleToImport module, @Nullable String newName) {
	if (!isExplicitlyUnselected(module)) {
	if (newName == null) {
	myNameOverrides.remove(module);
	}
	else {
	myNameOverrides.put(module, newName);
	}
	revalidate(myModules.keySet());
	}
	}

	private boolean isExplicitlyUnselected(ModuleToImport module) {
	return Objects.equal(false, myExplicitSelection.get(module));
	}

	@Nullable
	public MessageType getStatusSeverity(ModuleToImport module) {
	ModuleValidationState state = getModuleState(module);
	switch (state) {
	case OK:
	case NULL:
	return null;
	case NOT_FOUND:
	case DUPLICATE_MODULE_NAME:
	case INVALID_NAME:
	return MessageType.ERROR;
	case ALREADY_EXISTS:
	return getSelectedModules().contains(module) ? MessageType.ERROR : MessageType.WARNING;
	case REQUIRED:
	return MessageType.INFO;
	}
	throw new IllegalArgumentException(state.name());
	}

	@Nullable
	public String getStatusDescription(@NotNull ModuleToImport module) {
	ModuleValidationState state = getModuleState(module);
	switch (state) {
	case OK:
	case NULL:
	return null;
	case NOT_FOUND:
	return "Module sources not found";
	case ALREADY_EXISTS:
	if (isSelected(module) && isRequiredModule(module)) {
	return "Cannot rename module required by another";
	}
	return "Project already contains module with this name";
	case DUPLICATE_MODULE_NAME:
	return "More then one module with this name is selected";
	case REQUIRED:
	Iterable<String> requiredBy = Iterables.transform(myRequiredModules.get(module), new Function<ModuleToImport, String>() {
	@Override
	public String apply(ModuleToImport input) {
	return "'" + getModuleName(input) + "'";
	}
	});
	return ImportUIUtil.formatElementListString(requiredBy, "Required by module %s", "Required by modules %s and %s",
	"Required by modules %s and %d more");
	case INVALID_NAME:
	return getNameErrorMessage(getModuleName(module));
	}
	throw new IllegalStateException(state.name());
	}

	@Nullable
	public ModuleToImport getPrimary() {
	return myPrimaryModule;
	}

	@Nullable
	public VirtualFile getCurrentPath() {
	return mySelectedDirectory;
	}

	public Collection<ModuleToImport> getAllModules() {
	return ImmutableList.copyOf(myModules.keySet());
	}

	public boolean isSelected(@NotNull ModuleToImport module) {
	return !isUnselected(module, isRequiredModule(module));
	}

	public boolean canToggleModuleSelection(ModuleToImport module) {
	ModuleValidationState state = getModuleState(module);
	return state != ModuleValidationState.NOT_FOUND && !isRequiredModule(module);
	}

	public boolean canRename(ModuleToImport module) {
	return !isRequiredModule(module) && isSelected(module);
	}

	@VisibleForTesting
	public enum ModuleValidationState {
	OK, NULL, NOT_FOUND, ALREADY_EXISTS, REQUIRED, DUPLICATE_MODULE_NAME, INVALID_NAME
	}
	}