#12 -- Fix components for spring

src/main/java/ru/ulstu/extractor/heuristic/api/StructuralUnitIdentifier.java

@@ -9,10 +9,10 @@ import ru.ulstu.extractor.heuristic.component.BuildTool;
 import ru.ulstu.extractor.heuristic.component.ProgrammingLanguage;
 import ru.ulstu.extractor.heuristic.model.StructuralUnit;
 import ru.ulstu.extractor.heuristic.service.DetectorService;
+import ru.ulstu.extractor.heuristic.service.ProgrammingLanguageService;
 import ru.ulstu.extractor.util.StringUtils;
 
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.HashMap;
@@ -20,15 +20,16 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
+import static ru.ulstu.extractor.heuristic.service.DetectorService.LangDetectScrupulousness.HIGH;
+import static ru.ulstu.extractor.heuristic.service.DetectorService.LangDetectScrupulousness.LOW;
+
 public abstract class StructuralUnitIdentifier {
     public List<StructuralUnit> getEntityClasses(String projectPath, List<File> projectFiles, List<File> rootProjectFiles) {
         String subDirectory = getSourceDirectory(rootProjectFiles);
         return getEntityClasses(projectPath, subDirectory, projectFiles);
     }
 
-    protected abstract String getSourceDirectory(List<File> rootProjectFiles);
+    public abstract boolean isEntityClass(File file);
-
-    public abstract List<StructuralUnit> getEntityClasses(String projectPath, String subDirectory, List<File> projectFiles);
 
     public abstract List<StructuralUnit> getBusinessLogicClasses();
 
@@ -36,32 +37,33 @@ public abstract class StructuralUnitIdentifier {
 
     public abstract Optional<BuildTool> getBuildTool(List<File> rootDirectoryFiles);
 
+    public abstract boolean canAppliedToProject(String projectPath, List<File> projectFiles, List<File> rootProjectFiles);
+
+    public abstract boolean canAppliedToFile(File projectFile);
+
+    protected abstract List<StructuralUnit> getEntityClasses(String projectPath, String subDirectory, List<File> projectFiles);
+
+    protected abstract String getSourceDirectory(List<File> rootProjectFiles);
+
     protected abstract DetectorService getDetectorService();
 
-    protected abstract ProgrammingLanguage getProgrammingLanguage();
+    protected abstract ProgrammingLanguageService getProgrammingLanguageService();
 
-    protected abstract boolean isEntityClass(File file) throws FileNotFoundException;
+    protected abstract ProgrammingLanguage getProgrammingLanguage();
 
     protected abstract boolean isBusinessLogicClass(File file);
 
     protected Optional<ProgrammingLanguage> getMainProgrammingLanguage(String projectPath, List<File> projectFiles, List<File> rootProjectFiles) {
         String subDirectory = getSourceDirectory(rootProjectFiles);
-        Map<String, Integer> projectFileLanguageFrequency = new HashMap<>();
+        Map<ProgrammingLanguage, Integer> projectFileLanguageFrequency = new HashMap<>();
         projectFiles.stream()
                 .filter(file -> StringUtils.fileInSubdirectory(file.getPath(), projectPath, subDirectory))
                 .forEach(projectFile -> {
-                    try {
+                    Optional<ProgrammingLanguage> detectedLanguage = getMainProgrammingLanguage(projectFile, LOW);
-                        String detectedLanguage = getDetectorService().getDetectedLanguage(
+                    detectedLanguage.ifPresent(programmingLanguage -> projectFileLanguageFrequency.put(programmingLanguage, projectFileLanguageFrequency.getOrDefault(programmingLanguage, 0) + 1));
-                                projectFile.getName(),
-                                new String(Files.readAllBytes(projectFile.toPath())),
-                                DetectorService.LangDetectScrupulousness.LOW);
-                        projectFileLanguageFrequency.put(detectedLanguage, projectFileLanguageFrequency.getOrDefault(detectedLanguage, 0) + 1);
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                    }
                 });
 
-        Optional<Map.Entry<String, Integer>> mostFrequentLanguageEntry = projectFileLanguageFrequency
+        Optional<Map.Entry<ProgrammingLanguage, Integer>> mostFrequentLanguageEntry = projectFileLanguageFrequency
                 .entrySet()
                 .stream()
                 .max(Map.Entry.comparingByValue());
@@ -69,11 +71,21 @@ public abstract class StructuralUnitIdentifier {
             return Optional.empty();
         }
 
-        ProgrammingLanguage programmingLanguage = getProgrammingLanguage();
+        return Optional.of(mostFrequentLanguageEntry.get().getKey());
-        return programmingLanguage.getName().equals(mostFrequentLanguageEntry.get().getKey())
-                ? Optional.of(programmingLanguage)
-                : Optional.empty();
     }
 
-    public abstract boolean canAppliedToProject(String projectPath, List<File> projectFiles, List<File> rootProjectFiles);
+    protected Optional<ProgrammingLanguage> getMainProgrammingLanguage(File projectFile, DetectorService.LangDetectScrupulousness scrupulousness) {
+        String fileContent = "";
+        if (scrupulousness == HIGH) {
+            try {
+                fileContent = new String(Files.readAllBytes(projectFile.toPath()));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return getProgrammingLanguageService().getByName(getDetectorService().getDetectedLanguage(
+                projectFile.getName(),
+                fileContent,
+                scrupulousness));
+    }
 }

src/main/java/ru/ulstu/extractor/heuristic/component/JavaProgrammingLanguage.java

@@ -5,6 +5,9 @@
 
 package ru.ulstu.extractor.heuristic.component;
 
+import org.springframework.stereotype.Component;
+
+@Component
 public class JavaProgrammingLanguage extends ProgrammingLanguage {
     public JavaProgrammingLanguage() {
         super("java");

src/main/java/ru/ulstu/extractor/heuristic/component/ProgrammingLanguage.java

@@ -5,6 +5,8 @@
 
 package ru.ulstu.extractor.heuristic.component;
 
+import java.util.Locale;
+
 public abstract class ProgrammingLanguage {
     private final String name;
 
@@ -15,4 +17,12 @@ public abstract class ProgrammingLanguage {
     public String getName() {
         return name;
     }
+
+    public boolean canMappedByName(String programmingLanguageName) {
+        if (programmingLanguageName == null || programmingLanguageName.isBlank()) {
+            return false;
+        }
+        return getName().toLowerCase(Locale.ROOT).equals(programmingLanguageName.toLowerCase(Locale.ROOT))
+                || programmingLanguageName.toLowerCase(Locale.ROOT).contains(getName().toLowerCase(Locale.ROOT));
+    }
 }

src/main/java/ru/ulstu/extractor/heuristic/service/JavaIdentifier.java

@@ -23,15 +23,20 @@ import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
+import static ru.ulstu.extractor.heuristic.service.DetectorService.LangDetectScrupulousness.LOW;
+
 @Service
 public class JavaIdentifier extends StructuralUnitIdentifier {
     private final DetectorService detectorService;
     private final BuildToolService buildToolService;
+    private final ProgrammingLanguageService programmingLanguageService;
 
     public JavaIdentifier(DetectorService detectorService,
-                          BuildToolService buildToolService) {
+                          BuildToolService buildToolService,
+                          ProgrammingLanguageService programmingLanguageService) {
         this.detectorService = detectorService;
         this.buildToolService = buildToolService;
+        this.programmingLanguageService = programmingLanguageService;
     }
 
     @Override
@@ -40,6 +45,10 @@ public class JavaIdentifier extends StructuralUnitIdentifier {
                 &&*/ getMainProgrammingLanguage(projectPath, projectFiles, rootProjectFiles).orElse(null) instanceof JavaProgrammingLanguage;
     }
 
+    public boolean canAppliedToFile(File projectFile) {
+        return getMainProgrammingLanguage(projectFile, LOW).orElse(null) instanceof JavaProgrammingLanguage;
+    }
+
     @Override
     public List<StructuralUnit> getEntityClasses(String projectPath, String subDirectory, List<File> projectFiles) {
         return projectFiles.stream()
@@ -69,13 +78,18 @@ public class JavaIdentifier extends StructuralUnitIdentifier {
         return detectorService;
     }
 
+    @Override
+    protected ProgrammingLanguageService getProgrammingLanguageService() {
+        return programmingLanguageService;
+    }
+
     @Override
     protected ProgrammingLanguage getProgrammingLanguage() {
         return new JavaProgrammingLanguage();
     }
 
     @Override
-    protected boolean isEntityClass(File file) {
+    public boolean isEntityClass(File file) {
         try {
             return file.getName().endsWith("java") && classContainsAnnotation(file, "@Entity");
         } catch (Exception ex) {

src/main/java/ru/ulstu/extractor/heuristic/service/ProgrammingLanguageService.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 Anton Romanov - All Rights Reserved
+ * You may use, distribute and modify this code, please write to: romanov73@gmail.com.
+ */
+
+package ru.ulstu.extractor.heuristic.service;
+
+import org.springframework.stereotype.Service;
+import ru.ulstu.extractor.heuristic.component.ProgrammingLanguage;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class ProgrammingLanguageService {
+    private final List<ProgrammingLanguage> programmingLanguages;
+
+    public ProgrammingLanguageService(List<ProgrammingLanguage> programmingLanguages) {
+        this.programmingLanguages = programmingLanguages;
+    }
+
+    public Optional<ProgrammingLanguage> getByName(String programmingLanguageName) {
+        return programmingLanguages.stream().filter(lang -> lang.canMappedByName(programmingLanguageName)).findAny();
+    }
+}

src/main/java/ru/ulstu/extractor/heuristic/service/StructuralUnitService.java

@@ -38,4 +38,12 @@ public class StructuralUnitService {
                 .orElseThrow(() -> new RuntimeException("Identifier not found"));
         return selectedIdentifier.getEntityClasses(rootPath.getPath(), projectFiles, rootProjectFiles);
     }
+
+    public boolean containsEntity(File projectFile) {
+        StructuralUnitIdentifier selectedIdentifier = structuralUnitIdentifiers.stream()
+                .filter(structuralUnitIdentifier -> structuralUnitIdentifier.canAppliedToFile(projectFile))
+                .findAny()
+                .orElseThrow(() -> new RuntimeException("Identifier not found"));
+        return selectedIdentifier.isEntityClass(projectFile);
+    }
 }