A.k.lysenko solution

README.md

@@ -1,3 +1,4 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/9A22t-SS)
 Разработать standalone приложение, которое имеет следующие возможности:
 
 Принимает на вход проект в виде .jar файла

build.gradle.kts

@@ -1,5 +1,7 @@
 plugins {
-    id("java")
+    application
+    java
+    id("io.freefair.lombok") version "8.13.1"
 }
 
 group = "org.example"
@@ -10,11 +12,16 @@ repositories {
 }
 
 dependencies {
+    implementation("com.fasterxml.jackson.core:jackson-databind:2.0.1")
+    implementation("org.slf4j:slf4j-api:2.0.17")
+    implementation("ch.qos.logback:logback-classic:1.5.18")
     implementation("org.ow2.asm:asm:9.5")
     implementation("org.ow2.asm:asm-tree:9.5")
     implementation("org.ow2.asm:asm-analysis:9.5")
     implementation("org.ow2.asm:asm-util:9.5")
+}
 
+dependencies {
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")

src/main/java/org/example/Main.java

@@ -0,0 +1,67 @@
+package org.example;
+
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.example.configuration.ObjectMapperConfiguration;
+import org.example.model.AnalyzeResult;
+import org.example.model.JarFileMetrics;
+import org.example.service.ClassAnalyzerService;
+import org.example.service.util.ObjectMapperUtil;
+import org.objectweb.asm.ClassReader;
+
+import java.io.IOException;
+import java.util.jar.JarFile;
+
+@Slf4j
+public class Main {
+    public static void main(String[] args) {
+        var jarPath = "src/main/resources/simple.jar";
+
+        if (args.length != 1) {
+            log.error("Wrong arguments. First should be a jar file to analyze");
+            System.exit(1);
+        }
+
+        var objectMapper = ObjectMapperConfiguration.getObjectMapper();
+        jarPath = args[0];
+
+        var finalResult = new AnalyzeResult();
+
+        processJarFile(jarPath, finalResult, objectMapper);
+
+        log.info("Final result is: {}", objectMapper.writeValueAsString(finalResult));
+    }
+
+    @SneakyThrows
+    private static void processJarFile(String jarFilePath, AnalyzeResult finalResult, ObjectMapperUtil objectMapperUtil) {
+        var jarMetrics = new JarFileMetrics();
+        try (var jarFile = new JarFile(jarFilePath)) {
+            jarFile.stream()
+                    .filter(it -> it.getName().endsWith(".class"))
+                    .forEach(it -> {
+                        ClassReader reader;
+                        try {
+                            reader = new ClassReader(jarFile.getInputStream(it));
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                        reader.accept(new ClassAnalyzerService(jarMetrics), 0);
+                    });
+        }
+
+        jarMetrics.calculateMetrics();
+        log.info("Метрики по jar архиву: {}", objectMapperUtil.writeValueAsString(jarMetrics));
+
+        log.info("Максимальная глубина наследования: {}", jarMetrics.getMaxInheritanceDepth());
+        log.info("Средняя глубина наследования: {}", jarMetrics.getAvgInheritanceDepth());
+        log.info("Средняя метрика ABC: {}", jarMetrics.getAvgAbcMetric());
+        log.info("Среднее количество переопределенных методов: {}", jarMetrics.getAvgOverriddenMethods());
+        log.info("Среднее количество полей в классе: {}", jarMetrics.getAvgFieldCount());
+
+        finalResult.setMaxInheritanceDepth(jarMetrics.getMaxInheritanceDepth());
+        finalResult.setAverageExtendsLength(jarMetrics.getAvgInheritanceDepth());
+        finalResult.setAverageOverridesMethods(jarMetrics.getAvgOverriddenMethods());
+        finalResult.setAverageFieldsInClass(jarMetrics.getAvgFieldCount());
+        finalResult.setAverageAbcMetric(jarMetrics.getAvgAbcMetric());
+    }
+}

src/main/java/org/example/configuration/ObjectMapperConfiguration.java

@@ -0,0 +1,12 @@
+package org.example.configuration;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.experimental.UtilityClass;
+import org.example.service.util.ObjectMapperUtil;
+
+@UtilityClass
+public class ObjectMapperConfiguration {
+    public static ObjectMapperUtil getObjectMapper() {
+        return new ObjectMapperUtil(new ObjectMapper());
+    }
+}

src/main/java/org/example/model/ABCMetric.java

@@ -0,0 +1,11 @@
+package org.example.model;
+
+import lombok.Data;
+
+@Data
+public class ABCMetric {
+    private long assignments;
+    private long branches;
+    private long conditions;
+    private double metricValue;
+}

src/main/java/org/example/model/AnalyzeResult.java

@@ -0,0 +1,12 @@
+package org.example.model;
+
+import lombok.Data;
+
+@Data
+public class AnalyzeResult {
+    private int maxInheritanceDepth;
+    private double averageExtendsLength;
+    private double averageOverridesMethods;
+    private double averageFieldsInClass;
+    private double averageAbcMetric;
+}

src/main/java/org/example/model/ClassMetrics.java

@@ -0,0 +1,18 @@
+package org.example.model;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+public class ClassMetrics {
+    private String name;
+    private String parentClassName;
+    private int fieldCount;
+    private List<MethodMetrics> methodMetrics = new ArrayList<>();
+
+    public void addMetrics(MethodMetrics methodMetrics) {
+        this.methodMetrics.add(methodMetrics);
+    }
+}

src/main/java/org/example/model/JarFileMetrics.java

@@ -0,0 +1,123 @@
+package org.example.model;
+
+import lombok.Data;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Data
+public class JarFileMetrics {
+    private Map<String, String> classNameToParentName;
+    private Map<String, List<String>> classNameToMethodSignatures;
+    private Map<String, Integer> classNameToMaxDepth;
+    private Map<String, Integer> classNameToOverriddenMethodsCount;
+    private Map<String, ClassMetrics> classNameToClassMetrics;
+
+    public JarFileMetrics() {
+        this.classNameToParentName = new HashMap<>();
+        this.classNameToMethodSignatures = new HashMap<>();
+        this.classNameToMaxDepth = new HashMap<>();
+        this.classNameToOverriddenMethodsCount = new HashMap<>();
+        this.classNameToClassMetrics = new HashMap<>();
+    }
+
+    public void addClassNameToParentName(String className, String classParentName) {
+        this.classNameToParentName.put(className, classParentName);
+    }
+
+    public void addClassNameToMethodsSignatures(String className, List<String> methodSignatures) {
+        this.classNameToMethodSignatures.put(className, methodSignatures);
+    }
+
+    public void addClassNameToClassMetrics(ClassMetrics classMetrics) {
+        this.classNameToClassMetrics.put(classMetrics.getName(), classMetrics);
+    }
+
+    public void calculateMetrics() {
+        for (var className : classNameToParentName.keySet()) {
+            calculateMaxDepth(className);
+        }
+
+        for (var className : classNameToMethodSignatures.keySet()) {
+            var methods = classNameToMethodSignatures.get(className);
+            countOverriddenMethods(className, methods);
+        }
+    }
+
+    public int getMaxInheritanceDepth() {
+        return classNameToMaxDepth.values().stream()
+                .max(Integer::compareTo)
+                .orElse(0);
+    }
+
+    public double getAvgInheritanceDepth() {
+        return classNameToMaxDepth.values().stream()
+                .mapToInt(Integer::intValue)
+                .average()
+                .orElse(0.0);
+    }
+
+    public double getAvgAbcMetric() {
+        return classNameToClassMetrics.values().stream()
+                .flatMap(classMetrics -> classMetrics.getMethodMetrics().stream())
+                .map(MethodMetrics::getAbcMetric)
+                .mapToDouble(ABCMetric::getMetricValue)
+                .average()
+                .orElse(0.0);
+    }
+
+    public double getAvgOverriddenMethods() {
+        return classNameToOverriddenMethodsCount.values().stream()
+                .mapToInt(Integer::intValue)
+                .average()
+                .orElse(0.0);
+    }
+
+    public double getAvgFieldCount() {
+        return classNameToClassMetrics.values().stream()
+                .mapToInt(ClassMetrics::getFieldCount)
+                .average()
+                .orElse(0.0);
+    }
+
+    private void calculateMaxDepth(String className) {
+        var depth = 0;
+        var currentClassName = className;
+
+        while (classNameToParentName.containsKey(currentClassName)) {
+            depth++;
+            currentClassName = classNameToParentName.get(currentClassName);
+        }
+
+        classNameToMaxDepth.put(className, depth);
+    }
+
+    private void countOverriddenMethods(String className, List<String> methods) {
+        if (!classNameToParentName.containsKey(className)) {
+            classNameToOverriddenMethodsCount.put(className, 0);
+            return;
+        }
+
+        var parent = classNameToParentName.get(className);
+        Set<String> inheritedMethods = new HashSet<>();
+
+        // Собираем все методы всех родительских классов
+        while (parent != null) {
+            var parentMethods = classNameToMethodSignatures.get(parent);
+            if (parentMethods != null) {
+                inheritedMethods.addAll(parentMethods);
+            }
+            parent = classNameToParentName.get(parent);
+        }
+
+        // Считаем переопределения
+        var overriddenCount = methods.stream()
+                .filter(inheritedMethods::contains)
+                .count();
+
+        classNameToOverriddenMethodsCount.put(className, (int) overriddenCount);
+    }
+}

src/main/java/org/example/model/MethodMetrics.java

@@ -0,0 +1,25 @@
+package org.example.model;
+
+import lombok.Data;
+
+@Data
+public class MethodMetrics {
+    private String signature;
+    private ABCMetric abcMetric = new ABCMetric();
+
+    public void setAssignments(long assignments) {
+        this.getAbcMetric().setAssignments(assignments);
+    }
+
+    public void setBranches(long branches) {
+        this.getAbcMetric().setBranches(branches);
+    }
+
+    public void setConditions(long conditions) {
+        this.getAbcMetric().setConditions(conditions);
+    }
+
+    public void setMetricValue(double metricValue) {
+        this.getAbcMetric().setMetricValue(metricValue);
+    }
+}

src/main/java/org/example/service/ClassAnalyzerService.java

@@ -0,0 +1,59 @@
+package org.example.service;
+
+import lombok.extern.slf4j.Slf4j;
+import org.example.model.ClassMetrics;
+import org.example.model.JarFileMetrics;
+import org.example.model.MethodMetrics;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * @see <a href=https://asm.ow2.io/javadoc/org/objectweb/asm/ClassVisitor.html>org.objectweb.asm.ClassVisitor docs
+ */
+@Slf4j
+public class ClassAnalyzerService extends ClassVisitor {
+    private final ClassMetrics classMetrics;
+    private final JarFileMetrics jarFileMetrics;
+
+    public ClassAnalyzerService(JarFileMetrics jarFileMetrics) {
+        super(Opcodes.ASM9);
+        this.jarFileMetrics = jarFileMetrics;
+        this.classMetrics = new ClassMetrics();
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        classMetrics.setName(name);
+        classMetrics.setParentClassName(superName);
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+        classMetrics.setFieldCount(classMetrics.getFieldCount() + 1);
+        return super.visitField(access, name, descriptor, signature, value);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+        var methodMetrics = new MethodMetrics();
+        methodMetrics.setSignature(signature);
+        classMetrics.addMetrics(methodMetrics);
+        return new MethodAnalyzerService(methodMetrics);
+    }
+
+    @Override
+    public void visitEnd() {
+        jarFileMetrics.addClassNameToParentName(classMetrics.getName(), classMetrics.getParentClassName());
+        jarFileMetrics.addClassNameToMethodsSignatures(
+                classMetrics.getName(),
+                classMetrics.getMethodMetrics().stream()
+                        .map(MethodMetrics::getSignature)
+                        .toList()
+        );
+        jarFileMetrics.addClassNameToClassMetrics(classMetrics);
+        super.visitEnd();
+    }
+}