@dxworks/insider 2.9.1

package/lib/index.js

@@ -0,0 +1,13 @@
+const {insider} = require("./lib");
+const {Command} = require("commander");
+
+exports.insiderCommand = new Command()
+  .name('insider')
+  .description('Running Insider commands')
+  .option('-wd --working-directory', 'Selects the directory where Insider will store the results folder.' +
+    ` Defaults to the location where Insider is installed: ${__dirname}. If set to true it will use the current working directory process.cwd()`,
+    false)
+  .allowUnknownOption()
+  .action(insider)
+
+

package/lib/insider.js

@@ -0,0 +1,7 @@
+#! /usr/bin/env node
+'use strict'
+const {insider} = require("./lib");
+
+(async () => {
+  await insider();
+})();

package/lib/lib.js

@@ -0,0 +1,21 @@
+const {JavaCaller} = require('java-caller');
+
+async function insider(options) {
+  const java = new JavaCaller({
+    jar: 'insider.jar', // CLASSPATH referencing the package embedded jar files
+    mainClass: 'org.dxworks.insider.Insider',// Main class to call, must be available from CLASSPATH,
+    rootPath: __dirname,
+    minimumJavaVersion: 11,
+    output: 'console'
+  });
+
+  const args = [...process.argv];
+  let index = args.indexOf('insider'); //if it is called from dxw cli
+  if(index === -1)
+    index = 1
+  args.splice(0,  index + 1);
+  const {status} = await java.run(args, {cwd: options?.workingDirectory? process.cwd(): __dirname});
+  process.exitCode = status;
+}
+
+module.exports = {insider}

package/lombok.config

@@ -0,0 +1,2 @@
+# This file is generated by the 'io.freefair.lombok' Gradle plugin
+config.stopBubbling = true

package/mkdocs.yml

@@ -0,0 +1,18 @@
+site_name: Dxworks Insider
+
+theme:
+  name: material
+
+nav:
+  - Home: 'index.md'
+  - 'Installation': 'queryLanguage.md'
+  - 'Configuration':
+      - 'config/config.md'
+      - 'Languages': 'config/languages.md'
+      - 'Ignore Files': 'config/ignore.md'
+      - 'Fingerprints': 'config/fingerprints.md'
+      - 'Insider Config': 'config/insider.md'
+  - 'Commands':
+      - 'Detect': 'commands/detect.md'
+      - 'Find': 'commands/find.md'
+      - 'Inspect': 'commands/inspect.md'

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@dxworks/insider",
+  "version": "2.9.1",
+  "description": "Insider is a belt of tools built on the idea of searching regular expressions in code",
+  "keywords": [
+    "insider",
+    "java",
+    "regex"
+  ],
+  "homepage": "https://github.com/dxworks/insider#readme",
+  "bugs": {
+    "url": "https://github.com/dxworks/insider/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dxworks/insider.git"
+  },
+  "license": "Apache-2.0",
+  "author": "Mario Rivis",
+  "main": "dist/index.js",
+  "bin": {
+    "insider": "dist/insider.js"
+  },
+  "scripts": {
+    "build": "npm run clean && mkdir dist && cp lib/*.js dist && cp build/libs/insider*.jar dist/insider.jar && npm run copy-assets",
+    "copy-assets": "cp -R config dist/config",
+    "clean": "rimraf dist/",
+    "local": "npm run build && npm i"
+  },
+  "dependencies": {
+    "commander": "11.1.0",
+    "java-caller": "^2.7.0"
+  },
+  "devDependencies": {
+    "json": "^11.0.0",
+    "rimraf": "^3.0.2",
+    "sort-package-json": "^1.52.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com"
+  },
+  "dxw": {
+    "commands": [
+      {
+        "file": "dist/index.js",
+        "command": "insiderCommand"
+      }
+    ]
+  }
+}

package/releaseNotes/v2.6.0.md

@@ -0,0 +1 @@
+* added npm module

package/releaseNotes/v2.7.1.md

@@ -0,0 +1 @@
+Fixed null modifiers rule issue.

package/settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'insider'
+

package/src/main/java/org/dxworks/insider/ChronosTag.java

@@ -0,0 +1,14 @@
+package org.dxworks.insider;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+@AllArgsConstructor
+public class ChronosTag {
+    private String entity;
+    private String tag;
+    private Integer strength;
+}

package/src/main/java/org/dxworks/insider/Insider.java

@@ -0,0 +1,214 @@
+package org.dxworks.insider;
+
+import lombok.extern.slf4j.Slf4j;
+import me.tongfei.progressbar.ProgressBar;
+import me.tongfei.progressbar.ProgressBarStyle;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.dxworks.ignorerLibrary.Ignorer;
+import org.dxworks.ignorerLibrary.IgnorerBuilder;
+import org.dxworks.insider.commands.*;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+import org.dxworks.insider.technology.finder.LinguistService;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static org.dxworks.insider.constants.InsiderConstants.CONFIGURATION_FOLDER;
+import static org.dxworks.insider.constants.InsiderConstants.RESULTS_FOLDER;
+
+@Slf4j
+public class Insider {
+
+    private static HelpCommand helpCommand = new HelpCommand();
+    private static VersionCommand versionCommand = new VersionCommand();
+
+    public static void main(String[] args) {
+
+        if (args == null) {
+            System.err.println("Arguments cannot be null");
+            return;
+        }
+
+        List<String> argsList = List.of(args);
+        InsiderConfiguration.getInstance().readInsiderVersion();
+
+        if (args.length == 0) {
+            System.err.println("No command found");
+            helpCommand.execute(null, argsList);
+            return;
+        }
+
+        if (versionCommand.parse(argsList)) {
+            versionCommand.execute(null, argsList);
+            return;
+        }
+
+        if (helpCommand.parse(argsList)) {
+            helpCommand.execute(null, argsList);
+            return;
+        }
+
+        List<List<String>> commands = extractCommands(args).stream()
+                .filter(it -> !it.isEmpty())
+                .collect(Collectors.toList());
+
+        Map<List<String>, InsiderCommand> allCommandsConfig = commands.stream()
+                .filter(it -> getInsiderCommand(it) != null)
+                .collect(Collectors.toMap(Function.identity(), Insider::getInsiderCommand, (a, b) -> b, LinkedHashMap::new));
+
+        readInsiderConfiguration();
+        List<InsiderFile> insiderFiles = allCommandsConfig.values()
+                .stream()
+                .allMatch(it -> it instanceof NoFilesCommand)
+                ? new ArrayList<>()
+                : getInsiderFiles(allCommandsConfig);
+
+        AtomicInteger index = new AtomicInteger(1);
+        int commandsSize = allCommandsConfig.size();
+        allCommandsConfig.forEach((commandArgs, insiderCommand) -> {
+            System.out.printf("*******************\nCommand %s (%d/%d) \n*******************\n", insiderCommand.getName(), index.getAndIncrement(), commandsSize);
+
+            boolean isValidInput = insiderCommand.parse(commandArgs);
+            if (!isValidInput) {
+                log.error("Input is not valid!");
+                helpCommand.execute(null, commandArgs);
+                return;
+            }
+
+            List<InsiderFile> acceptedFiles =
+                    insiderFiles.stream().filter(it -> hasAcceptedExtension(it.getPath())).collect(Collectors.toList());
+
+            try {
+                if (insiderCommand instanceof NoFilesCommand) {
+                    insiderCommand.execute(null, commandArgs);
+                } else if (insiderCommand instanceof AllFilesCommand) {
+                    insiderCommand.execute(insiderFiles, commandArgs);
+                } else {
+                    insiderCommand.execute(acceptedFiles, commandArgs);
+                }
+            } catch (Exception e) {
+                System.out.println("Command " + insiderCommand.getName() + "finished with errors");
+                e.printStackTrace();
+            }
+        });
+
+        System.out.println("Insider " + InsiderConfiguration.getInstance().getInsiderVersion() + " finished analysis");
+    }
+
+    private static List<List<String>> extractCommands(String[] args) {
+        List<List<String>> commands = new ArrayList<>();
+        List<String> currentCommand = new ArrayList<>();
+        for (String arg : args) {
+            if ("AND".equals(arg)) {
+                commands.add(currentCommand);
+                currentCommand = new ArrayList<>();
+                continue;
+            }
+            currentCommand.add(arg);
+        }
+        commands.add(currentCommand);
+
+        return commands;
+    }
+
+    private static InsiderCommand getInsiderCommand(List<String> commandArgs) {
+        if (CollectionUtils.isEmpty(commandArgs))
+            return null;
+        switch (commandArgs.get(0)) {
+            case InsiderCommand.FIND:
+                return new FindCommand();
+            case InsiderCommand.DETECT:
+                return new DetectCommand();
+            case InsiderCommand.ADD:
+                return new AddCommand();
+            case InsiderCommand.DIAGNOSE:
+                return new DiagnoseCommand();
+            case InsiderCommand.CONVERT:
+                return new ConvertCommand();
+            case InsiderCommand.INSPECT:
+                return new InspectCommand();
+            case InsiderCommand.EXTRACT:
+                return new ExtractCommand();
+            case InsiderCommand.INDENT:
+                return new IndentationCount();
+            case InsiderCommand.MEASURE:
+                return new MeasureCommand();
+            default:
+                return null;
+        }
+    }
+
+    private static void readInsiderConfiguration() {
+        File resultsFolder = new File(RESULTS_FOLDER);
+        if (!resultsFolder.exists())
+            resultsFolder.mkdirs();
+
+        InsiderConfiguration.getInstance().load();
+        reportUnknownExtensions();
+    }
+
+    private static List<InsiderFile> getInsiderFiles(Map<List<String>, InsiderCommand> insiderCommand) {
+        Ignorer ignorer = new IgnorerBuilder(Paths.get(CONFIGURATION_FOLDER, ".ignore")).compile();
+
+        if (!insiderCommand.values().stream().allMatch(it -> it instanceof NoFilesCommand))
+            return readProjectFiles(InsiderConfiguration.getInstance().getRootFolder(), ignorer);
+        else return new ArrayList<>();
+    }
+
+    private static void reportUnknownExtensions() {
+        List<String> requiredLanguages = InsiderConfiguration.getInstance().getLanguages();
+        requiredLanguages.stream()
+                .filter(lang -> !LinguistService.getInstance().containsLanguage(lang))
+                .forEach(lang -> System.out.println("Unknown language " + lang));
+    }
+
+    private static List<InsiderFile> readProjectFiles(String rootFolder, Ignorer ignorer) {
+        List<InsiderFile> insiderFiles = new ArrayList<>();
+        try {
+            List<Path> pathList = Files.walk(Paths.get(rootFolder))
+                    .filter(Files::isRegularFile)
+                    .filter(ignorer::accepts)
+                    .collect(Collectors.toList());
+            try (ProgressBar pb = new ProgressBar("Reading files", pathList.size(), ProgressBarStyle.ASCII)) {
+                for (Path path : pathList) {
+                    pb.step();
+                    try {
+                        insiderFiles.add(InsiderFile.builder()
+                                .path(path.toAbsolutePath().toString())
+                                .name(path.getFileName().toString())
+                                .extension(FilenameUtils.getExtension(path.getFileName().toString()))
+                                .content(new String(Files.readAllBytes(path)))
+                                .size(Files.size(path))
+                                .build());
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return insiderFiles;
+    }
+
+    private static boolean hasAcceptedExtension(String filePath) {
+        LinguistService linguistService = LinguistService.getInstance();
+        if (InsiderConfiguration.getInstance().getLanguages().isEmpty()) {
+            return linguistService.hasAcceptedExtension(filePath, linguistService.getProgrammingLanguages());
+        }
+
+        return linguistService.hasAcceptedExtension(filePath);
+    }
+}

package/src/main/java/org/dxworks/insider/InsiderAnalysis.java

@@ -0,0 +1,7 @@
+package org.dxworks.insider;
+
+public interface InsiderAnalysis {
+    InsiderResult analyze(InsiderFile insiderFile);
+
+    boolean accepts(InsiderFile insiderFile);
+}

package/src/main/java/org/dxworks/insider/InsiderFile.java

@@ -0,0 +1,125 @@
+package org.dxworks.insider;
+
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import org.dxworks.insider.configuration.InsiderConfiguration;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiredArgsConstructor
+@Data
+public class InsiderFile {
+
+    private final String name;
+    private final String path;
+    private final String extension;
+
+    private final String content;
+
+    private List<Integer> lineBreaks;
+
+    private int lines;
+    private final long size;
+
+    private String fullyQualifiedName;
+
+    public static InsiderFileBuilder builder() {
+        return new InsiderFileBuilder();
+    }
+
+    public String getLine(Integer index) {
+        if (index == lines - 1)
+            return (content.substring(lineBreaks.get(index) + 1));
+        return content.substring(lineBreaks.get(index) + 1, lineBreaks.get(index + 1) + 1);
+    }
+
+    private void extractLineBreaks(String content) {
+        lineBreaks = new ArrayList<>();
+        lineBreaks.add(-1);
+        for (int i = 0; i < content.length(); i++) {
+            if (content.charAt(i) == '\n') {
+                lineBreaks.add(i);
+            }
+        }
+    }
+
+    public String getFullyQualifiedName() {
+        if (fullyQualifiedName == null)
+            fullyQualifiedName = Path.of(InsiderConfiguration.getInstance().getRootFolder()).toAbsolutePath()
+                    .relativize(Path.of(getPath()).toAbsolutePath())
+                    .normalize().toString().replace("\\", "/");
+        return fullyQualifiedName;
+    }
+
+    public int getLineNumberOfAbsoluteCharacterIndex(int index) {
+        for (int i = 0; i < lineBreaks.size(); i++) {
+            if (index <= lineBreaks.get(i))
+                return i;
+        }
+        return lineBreaks.size();
+    }
+
+    public int getLineIndexFromFileIndex(int fileIndex) {
+        return fileIndex - lineBreaks.get(getLineNumberOfAbsoluteCharacterIndex(fileIndex) - 1);
+    }
+
+    public static class InsiderFileBuilder {
+        private String name;
+        private String path;
+        private String extension;
+        private String content;
+        private long size;
+
+        InsiderFileBuilder() {
+        }
+
+        public InsiderFileBuilder name(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public InsiderFileBuilder path(String path) {
+            this.path = path;
+            return this;
+        }
+
+        public InsiderFileBuilder extension(String extension) {
+            this.extension = extension;
+            return this;
+        }
+
+        public InsiderFileBuilder content(String content) {
+            this.content = content;
+            return this;
+        }
+
+        public InsiderFileBuilder size(long size) {
+            this.size = size;
+            return this;
+        }
+
+        public InsiderFile build() {
+            InsiderFile insiderFile = new InsiderFile(name, path, extension, content, size);
+            insiderFile.init();
+            return insiderFile;
+        }
+
+        @Override
+        public String toString() {
+            return "InsiderFileBuilder{" +
+                "name='" + name + '\'' +
+                ", path='" + path + '\'' +
+                ", extension='" + extension + '\'' +
+                ", content='" + content + '\'' +
+                ", size=" + size +
+                '}';
+        }
+    }
+
+    private void init() {
+        extractLineBreaks(content);
+        lines = lineBreaks.size();
+    }
+}

package/src/main/java/org/dxworks/insider/InsiderOptions.java

@@ -0,0 +1,78 @@
+package org.dxworks.insider;
+
+import java.io.File;
+
+import static picocli.CommandLine.*;
+
+@Command(name = "insider")
+public class InsiderOptions {
+
+    @ArgGroup
+    InsiderCommands insiderCommands;
+
+    // @formatter:off
+    static class TechnologyFinderOptions {
+        @Option(names = {"find", "--find-technologies"},
+                description = {"TechnologyFinder is an analysis that find regular expressions",
+                        "( that should be provided in a configuration file )",
+                        "in your project files."},
+                paramLabel = "technology-finder")
+        boolean technologyFinderFile;
+
+        @Parameters(description = "FingerPrint Files to analyze")
+        File[] fingerPrintFiles;
+    }
+
+    static class AddOptions {
+        @Option(names = {"add", "--add-imports"},
+                description = "The path to the imports CSV file you want to clean.",
+                paramLabel = "imports_file")
+        boolean add;
+
+        @Parameters(hidden = true)
+        File[] files;
+
+        @Parameters(index = "0", description = "The csv file from where add libraries")
+        File csvFile;
+
+        @Parameters(index = "1", description = "The json file to add libraries to")
+        File jsonFile;
+    }
+
+    static class DiagnoseOptions {
+        @Option(names = {"diagnose", "-diag", "--diagnose-imports-file"})
+        boolean diagnoseFile;
+
+        @Parameters(description = "The path to the imports JSON file you want to diagnose.")
+        File jsonFile;
+    }
+
+    static class LibraryDetectorOptions {
+
+        @Option(names = {"detect", "--detect-libraries"},
+                description = {"Library Detector is a regex based analysis that finds all import statements",
+                        "in Java or C-based projects (C, Objective C, C++). It also aggregates the results",
+                        "on packages (for Java), or on libraries (through a header to library mapping file for C-based)",
+                        "For now, only Java detection is implemented"},
+                paramLabel = "library-discovery")
+        boolean libraryDiscovery;
+
+        @Parameters(description = "Path to ignored Imports file")
+        File ignoredImports;
+    }
+
+    static class InsiderCommands {
+        @ArgGroup(exclusive = false)
+        TechnologyFinderOptions technologyFinderOptions;
+
+        @ArgGroup(exclusive = false)
+        LibraryDetectorOptions libraryDetectorOptions;
+
+        @ArgGroup(exclusive = false)
+        AddOptions addOptions;
+
+        @ArgGroup(exclusive = false)
+        DiagnoseOptions diagnoseOptions;
+    }
+    // @formatter:on
+}

package/src/main/java/org/dxworks/insider/InsiderResult.java

@@ -0,0 +1,15 @@
+package org.dxworks.insider;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+@AllArgsConstructor
+public class InsiderResult {
+    private String name;
+    private String category;
+    private String file;
+    private Integer value;
+}

package/src/main/java/org/dxworks/insider/application/inspector/CodeRuleExtractor.java

@@ -0,0 +1,14 @@
+package org.dxworks.insider.application.inspector;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.application.inspector.dtos.PatternMatch;
+import org.dxworks.insider.application.inspector.dtos.Rule;
+
+import java.util.List;
+
+public class CodeRuleExtractor implements RuleExtractor {
+    @Override
+    public List<PatternMatch> extract(InsiderFile insiderFile, Rule rule) {
+        return null;
+    }
+}

package/src/main/java/org/dxworks/insider/application/inspector/CommentRuleExtractor.java

@@ -0,0 +1,14 @@
+package org.dxworks.insider.application.inspector;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.application.inspector.dtos.PatternMatch;
+import org.dxworks.insider.application.inspector.dtos.Rule;
+
+import java.util.List;
+
+public class CommentRuleExtractor implements RuleExtractor {
+    @Override
+    public List<PatternMatch> extract(InsiderFile insiderFile, Rule rule) {
+        return null;
+    }
+}

package/src/main/java/org/dxworks/insider/application/inspector/FileRuleExtractor.java

@@ -0,0 +1,14 @@
+package org.dxworks.insider.application.inspector;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.application.inspector.dtos.PatternMatch;
+import org.dxworks.insider.application.inspector.dtos.Rule;
+
+import java.util.List;
+
+public class FileRuleExtractor implements RuleExtractor {
+    @Override
+    public List<PatternMatch> extract(InsiderFile insiderFile, Rule rule) {
+        return null;
+    }
+}

package/src/main/java/org/dxworks/insider/application/inspector/RuleExtractor.java

@@ -0,0 +1,11 @@
+package org.dxworks.insider.application.inspector;
+
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.application.inspector.dtos.PatternMatch;
+import org.dxworks.insider.application.inspector.dtos.Rule;
+
+import java.util.List;
+
+public interface RuleExtractor {
+    List<PatternMatch> extract(InsiderFile insiderFile, Rule rule);
+}

package/src/main/java/org/dxworks/insider/application/inspector/dtos/Comment.java

@@ -0,0 +1,18 @@
+package org.dxworks.insider.application.inspector.dtos;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Comment {
+    private List<String> languages;
+    private String inline;
+    private String preffix;
+    private String suffix;
+    private List<CommentPattern> inlinePatterns;
+}