diff --git a/src/main/java/ru/ulstu/extractor/heuristic/api/StructuralUnitIdentifier.java b/src/main/java/ru/ulstu/extractor/heuristic/api/StructuralUnitIdentifier.java index 5b779cf..104f95d 100644 --- a/src/main/java/ru/ulstu/extractor/heuristic/api/StructuralUnitIdentifier.java +++ b/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 getEntityClasses(String projectPath, List projectFiles, List rootProjectFiles) { String subDirectory = getSourceDirectory(rootProjectFiles); return getEntityClasses(projectPath, subDirectory, projectFiles); } - protected abstract String getSourceDirectory(List rootProjectFiles); - - public abstract List getEntityClasses(String projectPath, String subDirectory, List projectFiles); + public abstract boolean isEntityClass(File file); public abstract List getBusinessLogicClasses(); @@ -36,32 +37,33 @@ public abstract class StructuralUnitIdentifier { public abstract Optional getBuildTool(List rootDirectoryFiles); + public abstract boolean canAppliedToProject(String projectPath, List projectFiles, List rootProjectFiles); + + public abstract boolean canAppliedToFile(File projectFile); + + protected abstract List getEntityClasses(String projectPath, String subDirectory, List projectFiles); + + protected abstract String getSourceDirectory(List 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 getMainProgrammingLanguage(String projectPath, List projectFiles, List rootProjectFiles) { String subDirectory = getSourceDirectory(rootProjectFiles); - Map projectFileLanguageFrequency = new HashMap<>(); + Map projectFileLanguageFrequency = new HashMap<>(); projectFiles.stream() .filter(file -> StringUtils.fileInSubdirectory(file.getPath(), projectPath, subDirectory)) .forEach(projectFile -> { - try { - String detectedLanguage = getDetectorService().getDetectedLanguage( - 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 detectedLanguage = getMainProgrammingLanguage(projectFile, LOW); + detectedLanguage.ifPresent(programmingLanguage -> projectFileLanguageFrequency.put(programmingLanguage, projectFileLanguageFrequency.getOrDefault(programmingLanguage, 0) + 1)); }); - Optional> mostFrequentLanguageEntry = projectFileLanguageFrequency + Optional> mostFrequentLanguageEntry = projectFileLanguageFrequency .entrySet() .stream() .max(Map.Entry.comparingByValue()); @@ -69,11 +71,21 @@ public abstract class StructuralUnitIdentifier { return Optional.empty(); } - ProgrammingLanguage programmingLanguage = getProgrammingLanguage(); - return programmingLanguage.getName().equals(mostFrequentLanguageEntry.get().getKey()) - ? Optional.of(programmingLanguage) - : Optional.empty(); + return Optional.of(mostFrequentLanguageEntry.get().getKey()); } - public abstract boolean canAppliedToProject(String projectPath, List projectFiles, List rootProjectFiles); + protected Optional 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)); + } } diff --git a/src/main/java/ru/ulstu/extractor/heuristic/component/JavaProgrammingLanguage.java b/src/main/java/ru/ulstu/extractor/heuristic/component/JavaProgrammingLanguage.java index 0a191ad..4b2a725 100644 --- a/src/main/java/ru/ulstu/extractor/heuristic/component/JavaProgrammingLanguage.java +++ b/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"); diff --git a/src/main/java/ru/ulstu/extractor/heuristic/component/ProgrammingLanguage.java b/src/main/java/ru/ulstu/extractor/heuristic/component/ProgrammingLanguage.java index 66c5850..5fa9c30 100644 --- a/src/main/java/ru/ulstu/extractor/heuristic/component/ProgrammingLanguage.java +++ b/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)); + } } diff --git a/src/main/java/ru/ulstu/extractor/heuristic/service/JavaIdentifier.java b/src/main/java/ru/ulstu/extractor/heuristic/service/JavaIdentifier.java index cf7ff7c..1168172 100644 --- a/src/main/java/ru/ulstu/extractor/heuristic/service/JavaIdentifier.java +++ b/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 getEntityClasses(String projectPath, String subDirectory, List 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) { diff --git a/src/main/java/ru/ulstu/extractor/heuristic/service/ProgrammingLanguageService.java b/src/main/java/ru/ulstu/extractor/heuristic/service/ProgrammingLanguageService.java new file mode 100644 index 0000000..405ae41 --- /dev/null +++ b/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 programmingLanguages; + + public ProgrammingLanguageService(List programmingLanguages) { + this.programmingLanguages = programmingLanguages; + } + + public Optional getByName(String programmingLanguageName) { + return programmingLanguages.stream().filter(lang -> lang.canMappedByName(programmingLanguageName)).findAny(); + } +} diff --git a/src/main/java/ru/ulstu/extractor/heuristic/service/StructuralUnitService.java b/src/main/java/ru/ulstu/extractor/heuristic/service/StructuralUnitService.java index 848ab20..84b0e6a 100644 --- a/src/main/java/ru/ulstu/extractor/heuristic/service/StructuralUnitService.java +++ b/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); + } }