JarMetrics.java

package org.example;

import org.example.graph.Graph;
import org.example.graph.Node;
import org.example.visitor.ClassCalculateMetrics;
import org.objectweb.asm.ClassReader;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import org.json.JSONObject;

public class JarMetrics {

    private String pathToJarFile;
    private Node root;
    private Map<String, Node> classMap;
    private Integer countOfClass = 0;
    private int a;
    private int b;
    private int c;
    private int countOfFields;
    private int countOfMethods;
    int maxDepth;
    double averageDepth;
    int overrideMethods;
    double averageOverrideMethods;
    double averageCountOfFields;

    private Graph graph = new Graph();

    public JarMetrics(String pathToJarFile) {
        this.pathToJarFile = pathToJarFile;
        root = new Node("java/lang/Object", "", new HashSet<>(), List.of("hashCode()", "toString()", "equals(Ljava/lang/Object;)", "wait()", "notify()", "notifyAll()"));
        classMap = new HashMap<>();
        classMap.put(root.getClassName(), root);

    }

    public void getMetrics() {

        try (JarFile sampleJar = new JarFile(pathToJarFile)) {
            Enumeration<JarEntry> enumeration = sampleJar.entries();

            while (enumeration.hasMoreElements()) {
                JarEntry entry = enumeration.nextElement();
                if (entry.getName().endsWith(".class")) {


                    ClassCalculateMetrics calculateMetrics = new ClassCalculateMetrics();
                    ClassReader cr = new ClassReader(sampleJar.getInputStream(entry));
                    cr.accept(calculateMetrics, 0);

                    countOfClass++;
                    a += calculateMetrics.getMetrics().getA();
                    b += calculateMetrics.getMetrics().getB();
                    c += calculateMetrics.getMetrics().getC();
                    countOfFields += calculateMetrics.getMetrics().getCountOfFields();
                    countOfMethods += calculateMetrics.getMetrics().getCountOfMethods();

                    Node classNode = new Node(calculateMetrics.getMetrics().getClassName(), calculateMetrics.getMetrics().getSuperClassName(), calculateMetrics.getMetrics().getNameOfInterfaces(), calculateMetrics.getMetrics().getNameOfMethods());


                    classMap.put(classNode.getClassName(), classNode);
                }
            }

            createGraph();

            // Запускаем dfs для подсчёта глубины наследования
            graph.dfs(root, 0);

            maxDepth = graph.getMaxDepth();
            averageDepth = graph.averageDepth();

            overrideMethods = calculateOverrideMethods();
            averageOverrideMethods = (double) overrideMethods / countOfMethods;
            averageCountOfFields = (double) countOfFields / countOfClass;


            writeToJson(pathToJarFile, a, b, c, averageCountOfFields,
                    maxDepth, averageDepth, averageOverrideMethods, countOfMethods, overrideMethods);

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static void writeToJson(String jarFileName, double aMetric, double bMetric, double cMetric,
                                          double fieldsAverage, double maxDepth, double averageDepth, double averageOverridenMethods,
                                          int methods, int overridenMethods) {
        JSONObject metricJson = new JSONObject();
        metricJson.put("jarName", jarFileName);
        metricJson.put("fieldsAverage", fieldsAverage);
        metricJson.put("A", aMetric);
        metricJson.put("B", bMetric);
        metricJson.put("C", cMetric);
        metricJson.put("ABC", Math.sqrt(aMetric * aMetric + bMetric * bMetric + cMetric * cMetric));
        metricJson.put("maxInheritanceDepth", maxDepth);
        metricJson.put("averageInheritanceDepth", averageDepth);
        metricJson.put("averageOverridenMethods", averageOverridenMethods);
        metricJson.put("methods", methods);
        metricJson.put("overridenMethods", overridenMethods);

        try {
            File file = new File("metrics.json");
            file.createNewFile();
            FileWriter fileWriter = new FileWriter(file);
            System.out.print(metricJson);

            fileWriter.write(metricJson.toString(4));
            fileWriter.flush();
            fileWriter.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private int calculateOverrideMethods() {

        // нужно посчитать переопределённые методы и у extends случаев и у implements
        // superClass или интерфейсы

        findAllSuperClasses();
        findAllInterfaces();

        return calculateOverrideMethodsInInterfaces() + calculateOverrideMethodsInSuperClasses();

    }

    private int calculateOverrideMethodsInSuperClasses() {

        int result = 0;
        for (Node node : classMap.values()) {

            for (String method : node.getNameOfMethods()) {
                for (Node parent : node.getSuperClasses()) {
                    if (parent != null && parent.getNameOfMethods().contains(method))
                        result++;
                }
            }
        }

        return result;
    }

    private int calculateOverrideMethodsInInterfaces() {
        int result = 0;

        for (Node node : classMap.values()) {

            for (String method : node.getNameOfMethods()) {
                for (String interfaceNode : node.getNameOfInterfaces()) {
                    Node parent = classMap.get(interfaceNode);
                    if (parent != null && parent.getNameOfMethods().contains(method))
                        result++;
                }
            }
        }

        return result;
    }

    private void findAllInterfaces() {

        for (Node node : classMap.values()) {
            findAllInterfaces(node, node);
        }

    }

    private void findAllInterfaces(Node children, Node parent) {

        Set<String> parentInterfaces = new HashSet<>(parent.getNameOfInterfaces());

        for (String nameInterface : parentInterfaces) {
            Node node = classMap.get(nameInterface);
            if (node != null) {
                children.getNameOfInterfaces().addAll(node.getNameOfInterfaces());
                findAllInterfaces(children, node);
            }
        }

    }

    /**
     * Здесь мы заполним всю цепочку наследования
     */
    private void findAllSuperClasses() {

        for (Node node : classMap.values()) {
            node.getSuperClasses().add(classMap.get(node.getSuperClassName()));
            findAllSuperClasses(node, node);
        }
    }

    private void findAllSuperClasses(Node children, Node parent) {

        Node nextParent = classMap.get(parent.getSuperClassName());
        if (nextParent != null) {
            children.getSuperClasses().add(nextParent);
            findAllSuperClasses(children, nextParent);
        }
    }

    private void createGraph() {

        for (Node from : classMap.values()) {
            Node to = classMap.get(from.getSuperClassName());
            graph.addEdge(from, to);
        }

        for (Node from : classMap.values()) {

            for (String interfacesName : from.getNameOfInterfaces()) {
                Node to = classMap.get(interfacesName);
                graph.addEdge(from, to);
            }
        }

    }


}