UpdateModelImports.java

package jetbrains.mps.lang.core.plugin;

/*Generated by MPS */

import jetbrains.mps.refactoring.participant.RefactoringParticipantBase;
import org.jetbrains.mps.openapi.model.SNodeReference;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.refactoring.participant.MoveNodeRefactoringParticipant;
import jetbrains.mps.smodel.structure.Extension;
import jetbrains.mps.refactoring.participant.RefactoringParticipant;
import java.util.List;
import org.jetbrains.mps.openapi.module.SRepository;
import jetbrains.mps.internal.collections.runtime.ListSequence;
import java.util.ArrayList;
import org.jetbrains.mps.openapi.module.SearchScope;
import jetbrains.mps.ide.findusages.model.SearchResults;
import jetbrains.mps.refactoring.participant.RefactoringSession;
import org.jetbrains.mps.openapi.model.SModel;
import org.jetbrains.mps.openapi.model.SReference;
import jetbrains.mps.internal.collections.runtime.Sequence;
import org.jetbrains.mps.openapi.language.SLanguage;
import jetbrains.mps.smodel.SModelInternal;
import jetbrains.mps.module.ReloadableModuleBase;
import jetbrains.mps.project.AbstractModule;
import org.jetbrains.mps.openapi.module.SModule;
import jetbrains.mps.smodel.SModelOperations;
import jetbrains.mps.project.dependency.GlobalModuleDependenciesManager;

public class UpdateModelImports extends RefactoringParticipantBase<SNodeReference, SNodeReference, SNode, SNode> implements MoveNodeRefactoringParticipant<SNodeReference, SNodeReference> {

  public static class UpdateModelImports_extension extends Extension.Default<MoveNodeRefactoringParticipant<?, ?>> {
    public UpdateModelImports_extension() {
      super("jetbrains.mps.refactoring.participant.MoveNodeParticipantEP");
    }
    public MoveNodeRefactoringParticipant<?, ?> get() {
      return new UpdateModelImports();
    }
  }

  public static final RefactoringParticipant.Option OPTION = new RefactoringParticipant.Option("moveNode.options.updateModelImports", "Update model imports");
  private MoveNodeRefactoringParticipant.MoveNodeRefactoringDataCollector<SNodeReference, SNodeReference> myDataCollector = new MoveNodeRefactoringParticipant.MoveNodeRefactoringDataCollector<SNodeReference, SNodeReference>() {
    public SNodeReference beforeMove(SNode nodeToMove) {
      return nodeToMove.getReference();
    }
    public SNodeReference afterMove(SNode movedNode) {
      return movedNode.getReference();
    }
  };
  public MoveNodeRefactoringParticipant.MoveNodeRefactoringDataCollector<SNodeReference, SNodeReference> getDataCollector() {
    return myDataCollector;
  }
  public List<RefactoringParticipant.Option> getAvailableOptions(SNodeReference initialState, SRepository repository) {
    return ListSequence.fromListAndArray(new ArrayList<RefactoringParticipant.Option>(), OPTION);
  }
  public List<RefactoringParticipant.Change<SNodeReference, SNodeReference>> getChanges(SNodeReference initialState, SRepository repository, List<RefactoringParticipant.Option> selectedOptions, SearchScope searchScope) {
    if (!(ListSequence.fromList(selectedOptions).contains(OPTION))) {
      return ListSequence.fromList(new ArrayList<RefactoringParticipant.Change<SNodeReference, SNodeReference>>());
    }
    return ListSequence.fromListAndArray(new ArrayList<RefactoringParticipant.Change<SNodeReference, SNodeReference>>(), new MoveNodeRefactoringParticipant.ChangeBase<SNodeReference, SNodeReference>() {
      public MoveNodeRefactoringParticipant<SNodeReference, SNodeReference> getParticipant() {
        return UpdateModelImports.this;
      }
      public SearchResults getSearchResults() {
        return new SearchResults();
      }
      public void confirm(final SNodeReference finalState, final SRepository repository, RefactoringSession refactoringSession) {
        refactoringSession.registerChange(new Runnable() {
          public void run() {
            SNode node = finalState.resolve(repository);
            SModel model = node.getModel();
            addLanguageImport(model, node.getConcept().getLanguage());
            for (SReference ref : Sequence.fromIterable(node.getReferences())) {
              addModelImport(model, ref.getTargetSModelReference().resolve(repository));
            }
          }
        });
      }
    });
  }
  public static void addLanguageImport(SModel model, SLanguage language) {
    if (!(model instanceof SModelInternal)) {
      return;
    }
    SModelInternal modelInternal = (SModelInternal) model;
    if (!(modelInternal.importedLanguageIds().contains(language))) {
      modelInternal.addLanguage(language);
    }
  }
  public static void addModelImport(SModel model, SModel targetModel) {
    if (!(model instanceof SModelInternal)) {
      return;
    }
    if (!(model.getModule() instanceof ReloadableModuleBase)) {
      return;
    }
    if (targetModel == null) {
      return;
    }
    if (targetModel.getModule() == null) {
      return;
    }
    SModelInternal modelInternal = (SModelInternal) model;
    AbstractModule module = (ReloadableModuleBase) model.getModule();
    SModule targetModule = targetModel.getModule();
    if (targetModel != model) {
      if (!(SModelOperations.getImportedModelUIDs(model).contains(targetModel.getReference()))) {
        modelInternal.addModelImport(targetModel.getReference());
      }
    }
    if (!(new GlobalModuleDependenciesManager(module).getModules(GlobalModuleDependenciesManager.Deptype.VISIBLE).contains(targetModule))) {
      module.addDependency(targetModule.getModuleReference(), false);
    }
  }
}