com.twitter.intellij.pants.service.project.model.ProjectInfo.java Source code

Introduction

Here is the source code for com.twitter.intellij.pants.service.project.model.ProjectInfo.java

Source

// Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
// Licensed under the Apache License, Version 2.0 (see LICENSE).

package com.twitter.intellij.pants.service.project.model;

import com.google.gson.GsonBuilder;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.containers.ContainerUtil;
import com.twitter.intellij.pants.model.TargetAddressInfo;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.TestOnly;

import java.util.*;

public class ProjectInfo {
    public static ProjectInfo fromJson(@NotNull String data) {
        final GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(TargetInfo.class, TargetInfoDeserializer.INSTANCE);
        builder.registerTypeAdapter(LibraryInfo.class, LibraryInfoDeserializer.INSTANCE);
        final ProjectInfo projectInfo = builder.create().fromJson(data, ProjectInfo.class);
        projectInfo.initTargetAddresses();

        return projectInfo;
    }

    @TestOnly
    public ProjectInfo() {
    }

    private final Logger LOG = Logger.getInstance(getClass());
    // id(org:name:version) to jars
    protected Map<String, LibraryInfo> libraries;
    // name to info
    protected Map<String, TargetInfo> targets;

    protected String version;

    @NotNull
    public String getVersion() {
        return version;
    }

    @Nullable
    protected PythonSetup python_setup = null;

    private static <T> List<Map.Entry<String, T>> getSortedEntries(Map<String, T> map) {
        return ContainerUtil.sorted(map.entrySet(), new Comparator<Map.Entry<String, T>>() {
            @Override
            public int compare(Map.Entry<String, T> o1, Map.Entry<String, T> o2) {
                return StringUtil.naturalCompare(o1.getKey(), o2.getKey());
            }
        });
    }

    public List<Map.Entry<String, LibraryInfo>> getSortedLibraries() {
        return getSortedEntries(getLibraries());
    }

    public Map<String, LibraryInfo> getLibraries() {
        return libraries;
    }

    public void setLibraries(Map<String, LibraryInfo> libraries) {
        this.libraries = libraries;
    }

    public List<Map.Entry<String, TargetInfo>> getSortedTargets() {
        return getSortedEntries(getTargets());
    }

    public Map<String, TargetInfo> getTargets() {
        return targets;
    }

    public void setTargets(Map<String, TargetInfo> targets) {
        this.targets = targets;
    }

    @Nullable
    public PythonSetup getPythonSetup() {
        return python_setup;
    }

    @Nullable
    public LibraryInfo getLibraries(@NotNull String libraryId) {
        if (libraries.containsKey(libraryId) && libraries.get(libraryId).getDefault() != null) {
            return libraries.get(libraryId);
        }
        int versionIndex = libraryId.lastIndexOf(':');
        if (versionIndex == -1) {
            return null;
        }
        final String libraryName = libraryId.substring(0, versionIndex);
        for (Map.Entry<String, LibraryInfo> libIdAndJars : libraries.entrySet()) {
            final String currentLibraryId = libIdAndJars.getKey();
            if (!StringUtil.startsWith(currentLibraryId, libraryName + ":")) {
                continue;
            }
            final LibraryInfo currentInfo = libIdAndJars.getValue();
            if (currentInfo != null) {
                LOG.info("Using " + currentLibraryId + " instead of " + libraryId);
                return currentInfo;
            }
        }
        return null;
    }

    @Nullable
    public TargetInfo getTarget(String targetName) {
        return targets.get(targetName);
    }

    public void addTarget(String targetName, TargetInfo info) {
        targets.put(targetName, info);
    }

    public void removeTargets(Collection<String> targetNames) {
        for (String targetName : targetNames) {
            removeTarget(targetName);
        }
    }

    public void renameTarget(@NotNull String targetName, @NotNull String newTargetName) {
        addTarget(newTargetName, getTarget(targetName));
        replaceDependency(targetName, newTargetName);
        removeTarget(targetName);
    }

    public void removeTarget(String targetName) {
        targets.remove(targetName);
        for (TargetInfo targetInfo : targets.values()) {
            targetInfo.getTargets().remove(targetName);
        }
    }

    public void replaceDependency(String targetName, String newTargetName) {
        for (TargetInfo targetInfo : targets.values()) {
            targetInfo.replaceDependency(targetName, newTargetName);
        }
    }

    private void initTargetAddresses() {
        for (Map.Entry<String, TargetInfo> entry : targets.entrySet()) {
            final TargetInfo info = entry.getValue();
            final String address = entry.getKey();
            for (TargetAddressInfo addressInfo : info.getAddressInfos()) {
                addressInfo.setTargetAddress(address);
            }
        }
    }

    /**
     * Helper method to get a distribution by target type.
     */
    public Map<String, Integer> getTargetsDistribution() {
        final Map<String, Integer> result = new HashMap<String, Integer>();
        for (TargetInfo targetInfo : targets.values()) {
            for (TargetAddressInfo addressInfo : targetInfo.getAddressInfos()) {
                final String type = addressInfo.getInternalPantsTargetType();
                final int currentValue = ContainerUtil.getOrCreate(result, type, 0);
                result.put(type, currentValue + 1);
            }
        }
        return result;
    }

    @Override
    public String toString() {
        return "ProjectInfo{" + "libraries=" + libraries + ", targets=" + targets + '}';
    }
}