@dxworks/insider 2.9.1

package/src/main/java/org/dxworks/insider/commands/ConvertCommand.java

@@ -0,0 +1,55 @@
+package org.dxworks.insider.commands;
+
+import lombok.extern.slf4j.Slf4j;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.technology.finder.parsers.JavaLibrariesCsvParser;
+import org.dxworks.insider.technology.finder.parsers.JsonFingerprintParser;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.List;
+
+@Slf4j
+public class ConvertCommand implements NoFilesCommand {
+    protected String sourceFile;
+    protected String targetFile;
+
+    @Override
+    public boolean parse(List<String> args) {
+        if (args.size() != 3)
+            return false;
+
+        sourceFile = args.get(1);
+        targetFile = args.get(2);
+
+        return fileExists(sourceFile);
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        try {
+            transformJsonFileToCsv(sourceFile, targetFile);
+        } catch (IOException e) {
+            log.error("Could not transform file!", e);
+        }
+    }
+
+    private void transformJsonFileToCsv(String jsonFile, String csvFile) throws IOException {
+        JsonFingerprintParser jsonFingerprintParser = new JsonFingerprintParser();
+        List<Technology> technologies = jsonFingerprintParser.parseTechnologiesFile(jsonFile);
+
+        JavaLibrariesCsvParser javaLibrariesCsvParser = new JavaLibrariesCsvParser();
+        javaLibrariesCsvParser.writeTechnologiesToFile(technologies, Paths.get(csvFile));
+    }
+
+    @Override
+    public String usage() {
+        return "insider convert <path_to_json> <path_to_csv>";
+    }
+
+    @Override
+    public String getName() {
+        return CONVERT;
+    }
+}

package/src/main/java/org/dxworks/insider/commands/DetectCommand.java

@@ -0,0 +1,42 @@
+package org.dxworks.insider.commands;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.library.detector.LibraryDetector;
+import org.dxworks.insider.library.detector.LibraryDetectorLanguage;
+import org.dxworks.insider.technology.finder.LinguistService;
+
+import java.util.List;
+
+public class DetectCommand implements InsiderCommand {
+
+    @Override
+    public boolean parse(List<String> args) {
+        return args.size() == 1;
+    }
+
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        LibraryDetector libraryDetector = new LibraryDetector(LibraryDetectorLanguage.JAVA);
+        insiderFiles.stream()
+                .filter(libraryDetector::accepts)
+                .forEach(libraryDetector::analyze);
+
+        libraryDetector.generateResults();
+    }
+
+    @Override
+    public String usage() {
+        return "insider detect";
+    }
+
+    @Override
+    public String getName() {
+        return DETECT;
+    }
+
+    @Override
+    public boolean acceptsFile(String path) {
+        return LinguistService.getInstance().hasAcceptedExtension(path, LibraryDetector.ACCEPTED_LANGUAGES);
+    }
+}

package/src/main/java/org/dxworks/insider/commands/DiagnoseCommand.java

@@ -0,0 +1,74 @@
+package org.dxworks.insider.commands;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.technology.finder.parsers.JsonFingerprintParser;
+import org.dxworks.insider.utils.ImportUtils;
+import org.dxworks.insider.utils.LibraryImport;
+import org.dxworks.insider.utils.LibraryImportInOtherTechnology;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class DiagnoseCommand implements NoFilesCommand {
+
+    private String file;
+
+    @Override
+    public boolean parse(List<String> args) {
+        if (args.size() != 2)
+            return false;
+
+        file = args.get(1);
+
+        return fileExists(file);
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+
+        JsonFingerprintParser jsonFingerprintParser = new JsonFingerprintParser();
+        List<Technology> jsonTechnologies = jsonFingerprintParser.parseTechnologiesFile(file);
+
+        List<String> duplicatedTechnologies = jsonTechnologies.stream()
+            .collect(Collectors.groupingBy(Technology::getName, Collectors.counting()))
+            .entrySet().stream()
+            .filter(e -> e.getValue() > 1)
+            .map(Map.Entry::getKey)
+            .collect(Collectors.toList());
+
+        System.out.println("Duplicated technologies: " + duplicatedTechnologies.toString());
+
+        List<LibraryImportInOtherTechnology> duplicatedFingerPrints = new ArrayList<>();
+
+        jsonTechnologies.forEach(technology -> {
+            List<String> fingerprints = technology.getFingerprints();
+            fingerprints.forEach(fingerprint ->
+                jsonTechnologies.forEach(otherTechnology -> {
+                    if (technology.equals(otherTechnology))
+                        return;
+                    if (otherTechnology.getFingerprints().contains(fingerprint)) {
+                        duplicatedFingerPrints.add(new LibraryImportInOtherTechnology(fingerprint, technology.getName(), otherTechnology.getName()));
+                    }
+                }));
+        });
+
+        System.out.println("Duplicated Fingerprints: " + duplicatedFingerPrints.stream()
+            .distinct()
+            .map(LibraryImport::get_import)
+            .map(ImportUtils::unwrapImportPackage)
+            .collect(Collectors.toList()));
+    }
+
+    @Override
+    public String usage() {
+        return "insider diagnose <path_to_json>";
+    }
+
+    @Override
+    public String getName() {
+        return DIAGNOSE;
+    }
+}

package/src/main/java/org/dxworks/insider/commands/ExtractCommand.java

@@ -0,0 +1,35 @@
+package org.dxworks.insider.commands;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.depext.DependencyExtractor;
+
+import java.util.List;
+
+public class ExtractCommand implements InsiderCommand {
+    private final DependencyExtractor dependencyExtractor = new DependencyExtractor();
+
+    @Override
+    public boolean parse(List<String> args) {
+        return true;
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        dependencyExtractor.processAndWriteResults(insiderFiles);
+    }
+
+    @Override
+    public String usage() {
+        return "insider extract";
+    }
+
+    @Override
+    public String getName() {
+        return EXTRACT;
+    }
+
+    @Override
+    public boolean acceptsFile(String path) {
+        return dependencyExtractor.acceptFile(path);
+    }
+}

package/src/main/java/org/dxworks/insider/commands/FindCommand.java

@@ -0,0 +1,102 @@
+package org.dxworks.insider.commands;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import me.tongfei.progressbar.ProgressBar;
+import me.tongfei.progressbar.ProgressBarBuilder;
+import me.tongfei.progressbar.ProgressBarStyle;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.InsiderResult;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.technology.finder.model.json.JsonConfigurationDTO;
+import org.dxworks.insider.technology.finder.parsers.JsonFingerprintParser;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.dxworks.insider.constants.InsiderConstants.RESULTS_FOLDER;
+
+@Slf4j
+public class FindCommand implements InsiderCommand {
+
+    private List<String> fingerprintFiles;
+
+    @Override
+    public boolean parse(List<String> args) {
+        if (args.size() == 1) {
+            return false;
+        }
+
+        List<String> files = args.subList(1, args.size());
+        fingerprintFiles = files.stream().filter(this::fileExists).collect(Collectors.toList());
+
+        return !fingerprintFiles.isEmpty() && files.size() == fingerprintFiles.size();
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        JsonFingerprintParser parser = new JsonFingerprintParser();
+
+        fingerprintFiles.forEach(file -> {
+            JsonConfigurationDTO configurationDTO = parser.getConfigurationDTO(file);
+
+            List<Technology> technologies = parser.parseTechnologiesFile(file);
+
+            List<InsiderResult> insiderResults;
+
+            try (ProgressBar pb = new ProgressBarBuilder()
+                .setInitialMax(insiderFiles.size())
+                .setUnit(" Files", 1)
+                .setTaskName("Matching")
+                .setStyle(ProgressBarStyle.ASCII)
+                .setUpdateIntervalMillis(100)
+                .setPrintStream(System.err)
+                .build()) {
+                insiderResults = insiderFiles.parallelStream()
+                    .flatMap(insiderFile ->
+                    {
+                        Stream<InsiderResult> insiderResultStream = technologies.parallelStream()
+                            .map(technology -> technology.analyze(insiderFile))
+                            .filter(Objects::nonNull)
+                            .filter(insiderResult -> insiderResult.getValue() > 0);
+                        pb.step();
+                        return insiderResultStream;
+                    })
+                    .collect(Collectors.toList());
+            }
+            int sum = insiderResults.stream().mapToInt(InsiderResult::getValue).sum();
+
+            System.out.println(sum);
+
+            String outputFileName = configurationDTO.getOutputFileName();
+            if (outputFileName == null) {
+                outputFileName = InsiderConfiguration.getInstance().getProjectID() + "-" + Paths.get(file).toFile().getName();
+            }
+
+            ObjectMapper objectMapper = new ObjectMapper();
+            File outputFile = Paths.get(RESULTS_FOLDER, outputFileName).toFile();
+            try {
+                objectMapper.writerWithDefaultPrettyPrinter().writeValue(new FileWriter(outputFile), insiderResults);
+            } catch (IOException e) {
+                log.error("Could not write JSON file" + outputFile + "!", e);
+            }
+        });
+    }
+
+    @Override
+    public String usage() {
+        return "insider find <paths_to_json>...";
+    }
+
+    @Override
+    public String getName() {
+        return FIND;
+    }
+}

package/src/main/java/org/dxworks/insider/commands/HelpCommand.java

@@ -0,0 +1,56 @@
+package org.dxworks.insider.commands;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class HelpCommand implements NoFilesCommand {
+    @Override
+    public boolean parse(List<String> args) {
+        if (args.size() != 1)
+            return false;
+
+        return HELP.contains(args.get(0));
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        String usage = "Insider " + InsiderConfiguration.getInstance().getInsiderVersion() + " -  usage guide:\n";
+        usage += "Configure the source root and the project id in the config/insider-conf.properties file\n\n";
+
+        usage += "This is a list of the commands:\n";
+
+        usage += Stream.of(
+                        new HelpCommand(),
+                        new VersionCommand(),
+                        new AddCommand(),
+                        new ConvertCommand(),
+                        new DiagnoseCommand(),
+                        new DetectCommand(),
+                        new FindCommand(),
+                        new InspectCommand(),
+                        new ExtractCommand(),
+                        new MeasureCommand(),
+                        new IndentationCount())
+                .map(InsiderCommand::usage)
+                .map(s -> "\t" + s)
+                .collect(Collectors.joining("\n"));
+
+        usage += "\n\nPlease run insider with the specified commands from the folder you have installed Insider to!\n";
+
+        System.out.println(usage);
+    }
+
+    @Override
+    public String usage() {
+        return "insider {-h | -help | --help | help}";
+    }
+
+    @Override
+    public String getName() {
+        return "help";
+    }
+}

package/src/main/java/org/dxworks/insider/commands/IndentationCount.java

@@ -0,0 +1,69 @@
+package org.dxworks.insider.commands;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.SneakyThrows;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.InsiderResult;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+import org.dxworks.insider.constants.InsiderConstants;
+
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.IntSummaryStatistics;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class IndentationCount implements AllFilesCommand {
+    @Override
+    public boolean parse(List<String> args) {
+        return args.size() == 1;
+    }
+
+    @SneakyThrows
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        List<InsiderResult> insiderResults = insiderFiles.stream().flatMap(file -> {
+                    IntSummaryStatistics summary = Arrays.stream(file.getContent().split("\n"))
+                            .filter(l -> !l.isBlank())
+                            .mapToInt(this::getLineIndentation)
+                            .summaryStatistics();
+
+                    return Stream.of(new InsiderResult("max_indentation", "complexity", file.getFullyQualifiedName(), summary.getMax()),
+                            new InsiderResult("avg_indentation", "complexity", file.getFullyQualifiedName(), (int) Math.round(summary.getAverage())),
+                            new InsiderResult("total_indentation", "complexity", file.getFullyQualifiedName(), (int) summary.getSum())
+                            );
+                }
+        ).collect(Collectors.toList());
+
+        ObjectMapper objectMapper = new ObjectMapper();
+
+        objectMapper.writeValue(Path.of(InsiderConstants.RESULTS_FOLDER, InsiderConfiguration.getInstance().getProjectID() + "-indentation.json").toFile(), insiderResults);
+    }
+
+    private int getLineIndentation(String l) {
+        int indentation = 0;
+        for (int i = 0; i < l.toCharArray().length; i++) {
+            char ch = l.charAt(i);
+            if (Character.isWhitespace(ch)) {
+                if (ch == '\t')
+                    indentation += 2;
+                if (ch == ' ')
+                    indentation += 1;
+            } else {
+                break;
+            }
+        }
+        return indentation / 2;
+    }
+
+    @Override
+    public String usage() {
+        return "insider indent";
+    }
+
+    @Override
+    public String getName() {
+        return INDENT;
+    }
+}

package/src/main/java/org/dxworks/insider/commands/InsiderCommand.java

@@ -0,0 +1,71 @@
+package org.dxworks.insider.commands;
+
+import org.dxworks.insider.InsiderFile;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+public interface InsiderCommand {
+
+    Logger log = LoggerFactory.getLogger(InsiderCommand.class);
+
+    String DETECT = "detect";
+    String FIND = "find";
+    String ADD = "add";
+    String DIAGNOSE = "diagnose";
+    String CONVERT = "convert";
+    String INSPECT = "inspect";
+    String EXTRACT = "extract";
+    String INDENT = "indent";
+    String MEASURE = "measure";
+    List<String> VERSION = Arrays.asList("version", "-version", "--version", "-v");
+    List<String> HELP = Arrays.asList("help", "-help", "--help", "-h");
+
+    boolean parse(List<String> args);
+
+    default boolean fileExists(String filePath) {
+        Path path = Path.of(filePath).toAbsolutePath();
+
+        if (!Files.exists(path)) {
+            log.error("File " + path.toAbsolutePath() + " does not exist");
+            return false;
+        }
+
+        if (!Files.isRegularFile(path)) {
+            log.error("File " + path.toAbsolutePath() + " is not a file!");
+            return false;
+        }
+
+        return true;
+    }
+
+    default boolean folderExists(String folderPath) {
+        Path path = Paths.get(folderPath).toAbsolutePath();
+        if (!Files.exists(path)) {
+            log.error("Folder " + path.toAbsolutePath() + " does not exist");
+            return false;
+        }
+
+        if (!Files.isDirectory(path)) {
+            log.error("Folder " + path.toAbsolutePath() + " is not a firectory!");
+            return false;
+        }
+
+        return true;
+    }
+
+    default boolean acceptsFile(String path) {
+        return true;
+    }
+
+    void execute(List<InsiderFile> insiderFiles, List<String> args);
+
+    String usage();
+
+    String getName();
+}

package/src/main/java/org/dxworks/insider/commands/InspectCommand.java

@@ -0,0 +1,98 @@
+package org.dxworks.insider.commands;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import me.tongfei.progressbar.ProgressBar;
+import me.tongfei.progressbar.ProgressBarBuilder;
+import me.tongfei.progressbar.ProgressBarStyle;
+import org.apache.commons.lang.math.IntRange;
+import org.dxworks.insider.ChronosTag;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.InsiderResult;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+import org.dxworks.insider.application.inspector.dtos.Rule;
+import org.dxworks.insider.application.inspector.services.CommentService;
+import org.dxworks.insider.application.inspector.services.RuleService;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.dxworks.insider.constants.InsiderConstants.RESULTS_FOLDER;
+
+@Slf4j
+public class InspectCommand implements InsiderCommand {
+
+    private List<String> ruleFiles;
+
+    @Override
+    public boolean parse(List<String> args) {
+        if (args.size() == 1)
+            return false;
+
+        List<String> files = args.subList(1, args.size());
+        ruleFiles = files.stream().filter(filePath -> folderExists(filePath) || fileExists(filePath)).collect(Collectors.toList());
+
+        return !ruleFiles.isEmpty() && files.size() == ruleFiles.size();
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        RuleService ruleService = new RuleService();
+        List<Rule> rules = ruleService.getRuleFromFiles(ruleFiles);
+        rules.forEach(Rule::transformPatterns);
+
+        List<InsiderResult> insiderResults;
+
+        try (ProgressBar pb = new ProgressBarBuilder()
+                .setInitialMax(insiderFiles.size())
+                .setUnit(" Files", 1)
+                .setTaskName("Inspecting...")
+                .setStyle(ProgressBarStyle.ASCII)
+                .setUpdateIntervalMillis(100)
+                .setPrintStream(System.err)
+                .build()) {
+            insiderResults = insiderFiles.parallelStream()
+                    .flatMap(insiderFile -> {
+                        List<IntRange> commentRanges = getCommentRanges(insiderFile);
+
+                        Stream<InsiderResult> insiderResultStream = rules.parallelStream()
+                                .flatMap(rule -> rule.analyze(insiderFile, commentRanges).stream());
+                        pb.step();
+                        return insiderResultStream;
+                    })
+                    .collect(Collectors.toList());
+
+            List<ChronosTag> chronosTags = insiderResults.stream().map(insiderResult -> new ChronosTag(insiderResult.getFile(), "appinspector." + insiderResult.getName(), insiderResult.getValue())).collect(Collectors.toList());
+            Map<String, Map<String, List<ChronosTag>>> chronosResult = Map.of("file", Map.of("concerns", chronosTags));
+
+            ObjectMapper objectMapper = new ObjectMapper();
+            objectMapper.writerWithDefaultPrettyPrinter().writeValue(Paths.get(RESULTS_FOLDER, InsiderConfiguration.getInstance().getProjectID() + "-tags.json").toFile(), insiderResults);
+            objectMapper.writerWithDefaultPrettyPrinter().writeValue(Paths.get(RESULTS_FOLDER, InsiderConfiguration.getInstance().getProjectID() + "-chronos-tags.json").toFile(), chronosResult);
+        } catch (IOException e) {
+            log.error("Inspect command finished unsuccessfully!", e);
+        }
+    }
+
+    private List<IntRange> getCommentRanges(InsiderFile insiderFile) {
+        List<IntRange> commentRanges = new ArrayList<>();
+        CommentService commentService = CommentService.getInstance();
+        commentRanges.addAll(commentService.extractInlineCommentLines(insiderFile));
+        commentRanges.addAll(commentService.extractMultilineCommentLines(insiderFile));
+        return commentRanges;
+    }
+
+    @Override
+    public String usage() {
+        return "insider inspect <paths_to_rule>...";
+    }
+
+    @Override
+    public String getName() {
+        return INSPECT;
+    }
+}

package/src/main/java/org/dxworks/insider/commands/MeasureCommand.java

@@ -0,0 +1,47 @@
+package org.dxworks.insider.commands;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.dxworks.insider.ChronosTag;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.dxworks.insider.constants.InsiderConstants.RESULTS_FOLDER;
+
+public class MeasureCommand implements AllFilesCommand {
+    @Override
+    public boolean parse(List<String> args) {
+        return args.size() == 1;
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+        List<ChronosTag> sizeTags = insiderFiles.stream().flatMap(insiderFile -> Stream.of(
+            new ChronosTag(insiderFile.getFullyQualifiedName(), "loc", insiderFile.getLines()),
+            new ChronosTag(insiderFile.getFullyQualifiedName(), "size", (int) insiderFile.getSize()))
+        ).collect(Collectors.toList());
+
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            objectMapper.writerWithDefaultPrettyPrinter().writeValue(Paths.get(RESULTS_FOLDER, InsiderConfiguration.getInstance().getProjectID() + "-size.json").toFile(), sizeTags);
+        } catch (IOException e) {
+            System.err.println("Measure command finished unsuccessfully");
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public String usage() {
+        return "insider measure";
+    }
+
+    @Override
+    public String getName() {
+        return MEASURE;
+    }
+}

package/src/main/java/org/dxworks/insider/commands/NoFilesCommand.java

@@ -0,0 +1,4 @@
+package org.dxworks.insider.commands;
+
+public interface NoFilesCommand extends InsiderCommand {
+}