@dxworks/insider 2.9.1

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

@@ -0,0 +1,44 @@
+package org.dxworks.insider.application.inspector.dtos;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.regex.Pattern.*;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public
+class CommentPattern {
+    private String pattern;
+    private List<String> modifiers;
+
+    @JsonIgnore
+    private int regexFlags = -1;
+
+    public int createModifier() {
+        if (regexFlags != -1)
+            return regexFlags;
+
+        regexFlags = 0;
+
+        if (modifiers == null)
+            modifiers = new ArrayList<>();
+
+        if (modifiers.contains("i"))
+            regexFlags = regexFlags | CASE_INSENSITIVE;
+
+        if (modifiers.contains("d"))
+            regexFlags = regexFlags | DOTALL;
+
+        if (modifiers.contains("m"))
+            regexFlags = regexFlags | MULTILINE;
+
+        return regexFlags;
+    }
+}

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

@@ -0,0 +1,15 @@
+package org.dxworks.insider.application.inspector.dtos;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Condition {
+    private InsiderPattern pattern;
+    private String search_in;
+    private boolean negate_finding;
+    private String _comment;
+}

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

@@ -0,0 +1,149 @@
+package org.dxworks.insider.application.inspector.dtos;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.math.IntRange;
+import org.dxworks.insider.InsiderFile;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import java.util.stream.Collectors;
+import static java.util.regex.Pattern.*;
+
+@Slf4j
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class InsiderPattern {
+    private static final String REGEX_WORD = "regex-word";
+
+    private String pattern;
+    private String type;
+    private String confidence;
+    private List<String> modifiers;
+    private List<String> scopes;
+    private String _comment;
+    private boolean hasErrors = false;
+    @JsonIgnore
+    private int regexFlags = -1;
+
+    public List<PatternMatch> getMatches(InsiderFile file, List<IntRange> commentRanges) {
+        if (hasErrors)
+            return Collections.emptyList();
+
+        if (scopes.contains("all") || scopes.containsAll(Arrays.asList("code", "comment"))) {
+            return matchesInEntireFile(file);
+        }
+
+        List<PatternMatch> matches = new ArrayList<>();
+
+        if (scopes.contains("code")) {
+            matches.addAll(getCodeMatches(file, commentRanges));
+        }
+        if (scopes.contains("comment")) {
+            matches.addAll(getCommentMatches(file, commentRanges));
+        }
+
+        return matches;
+    }
+
+    public void transformPattern() {
+        if (REGEX_WORD.equals(type))
+            transformPatternIfWord();
+        if ("string".equals(type)) {
+            pattern = Pattern.quote(pattern);
+            pattern = String.format("\\b(%s)\\b", pattern);
+        }
+        if ("substring".equals(type))
+            pattern = Pattern.quote(pattern);
+    }
+
+    private List<PatternMatch> matchesInEntireFile(InsiderFile file) {
+        List<PatternMatch> matches = new ArrayList<>();
+        try {
+            Matcher matcher = Pattern.compile(pattern, createModifier()).matcher(file.getContent());
+            while (matcher.find()) {
+                int start = matcher.start();
+                int end = matcher.end();
+                PatternMatch patternMatch = createPatternMatch(start, end, file);
+                matches.add(patternMatch);
+            }
+        } catch (PatternSyntaxException e) {
+            hasErrors = true;
+            System.out.println();
+            log.error("Could not compile pattern '{}' due to: {}", pattern, e.getMessage());
+        }
+        return matches;
+    }
+
+    private int createModifier() {
+        if(regexFlags != -1)
+            return regexFlags;
+
+        regexFlags = 0 ;
+
+        if(modifiers == null)
+            modifiers = new ArrayList<>();
+
+        if(modifiers.contains("i"))
+            regexFlags = regexFlags | CASE_INSENSITIVE;
+
+        if(modifiers.contains("d"))
+            regexFlags = regexFlags | DOTALL;
+
+        if(modifiers.contains("m"))
+            regexFlags = regexFlags | MULTILINE;
+
+        return regexFlags;
+    }
+
+    private List<PatternMatch> getCommentMatches(InsiderFile file, List<IntRange> commentRanges) {
+        return matchesInEntireFile(file).stream()
+                .filter(patternMatch -> isInComment(patternMatch, commentRanges))
+                .collect(Collectors.toList());
+    }
+
+    private boolean isInComment(PatternMatch patternMatch, List<IntRange> commentRanges) {
+        return commentRanges.stream().anyMatch(range -> range.containsRange(patternMatch.getAbsoluteRange()));
+    }
+
+    private boolean isOutsideOfComment(PatternMatch patternMatch, List<IntRange> commentRanges) {
+        return commentRanges.stream().noneMatch(range -> range.overlapsRange(patternMatch.getAbsoluteRange()));
+    }
+
+    private List<PatternMatch> getCodeMatches(InsiderFile file, List<IntRange> commentRanges) {
+        return matchesInEntireFile(file).stream()
+                .filter(patternMatch -> isOutsideOfComment(patternMatch, commentRanges))
+                .collect(Collectors.toList());
+    }
+
+    private PatternMatch createPatternMatch(int start, int end, InsiderFile file) {
+        return PatternMatch.builder()
+                .globalStartIndex(start)
+                .globalEndIndex(end)
+                .startIndex(file.getLineIndexFromFileIndex(start))
+                .endIndex(file.getLineIndexFromFileIndex(end))
+                .startLine(file.getLineNumberOfAbsoluteCharacterIndex(start))
+                .endLine(file.getLineNumberOfAbsoluteCharacterIndex(end))
+                .matchContent(file.getContent().substring(start, end))
+                .build();
+    }
+
+    private void transformPatternIfWord() {
+        if (pattern.contains("\\b")) {
+            return;
+        }
+        pattern = String.format("\\b(%s)\\b", pattern);
+    }
+
+}

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

@@ -0,0 +1,23 @@
+package org.dxworks.insider.application.inspector.dtos;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import org.apache.commons.lang.math.IntRange;
+
+@Data
+@Builder
+@AllArgsConstructor
+public class PatternMatch {
+    private String matchContent;
+    private int startLine;
+    private int endLine;
+    private int globalStartIndex;
+    private int globalEndIndex;
+    private int startIndex;
+    private int endIndex;
+
+    public IntRange getAbsoluteRange() {
+        return new IntRange(globalEndIndex, globalEndIndex);
+    }
+}

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

@@ -0,0 +1,61 @@
+package org.dxworks.insider.application.inspector.dtos;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang.math.IntRange;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.InsiderResult;
+import org.dxworks.insider.technology.finder.LinguistService;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Rule {
+    private String name;
+    private String id;
+    private String description;
+    private List<String> applies_to;
+    private List<String> tags;
+    private String severity;
+    private List<InsiderPattern> patterns;
+    private List<String> overrides;
+    private List<Condition> conditions;
+    private String _comment;
+
+
+    public List<InsiderResult> analyze(InsiderFile file, List<IntRange> commentRanges) {
+        if (appliesTo(file)) {
+            List<PatternMatch> matches = patterns.parallelStream()
+                    .flatMap(pattern -> pattern.getMatches(file, commentRanges).stream())
+                    .collect(Collectors.toList());
+
+            if (matches.size() > 0)
+                return tags.stream()
+                        .map(tag -> InsiderResult.builder()
+                                .file(file.getFullyQualifiedName())
+                                .category("")
+                                .name(tag)
+                                .value(matches.size())
+                                .build())
+                        .collect(Collectors.toList());
+        }
+
+        return Collections.emptyList();
+    }
+
+    public boolean appliesTo(InsiderFile insiderFile) {
+        return CollectionUtils.isEmpty(applies_to) || LinguistService.getInstance().hasAcceptedExtension(insiderFile, applies_to);
+    }
+
+    public void transformPatterns() {
+        patterns.forEach(InsiderPattern::transformPattern);
+    }
+}

package/src/main/java/org/dxworks/insider/application/inspector/services/CommentService.java

@@ -0,0 +1,165 @@
+package org.dxworks.insider.application.inspector.services;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.math.IntRange;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.application.inspector.dtos.Comment;
+import org.dxworks.insider.exceptions.InsiderException;
+import org.dxworks.insider.technology.finder.LinguistService;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class CommentService {
+
+    private static final String COMMENTS_FILE_NAME = "comments.json";
+    private static CommentService _instance = null;
+
+    private List<Comment> comments;
+
+    private CommentService() {
+        loadComments();
+    }
+
+    public static CommentService getInstance() {
+        if (_instance == null)
+            _instance = new CommentService();
+        return _instance;
+    }
+
+    public void loadComments() {
+        ObjectMapper objectMapper = new ObjectMapper();
+
+        try {
+            comments = objectMapper.readValue(Paths.get("config", COMMENTS_FILE_NAME).toFile(), new TypeReference<List<Comment>>() {
+            });
+        } catch (IOException e) {
+            throw new InsiderException(
+                    "Could not load comment configuration from file. Please make sure a file called "
+                            + COMMENTS_FILE_NAME + " exists in the Insider config directory.", e);
+        }
+    }
+
+    public List<IntRange> extractInlineCommentLines(InsiderFile file) {
+        List<IntRange> inlineComments = new ArrayList<>();
+
+        Comment commentStyle = getCommentForFile(file);
+        if (commentStyle != null) {
+            String inlineCommentPrefix = commentStyle.getInline();
+            if (inlineCommentPrefix != null) {
+                Matcher matcher = Pattern.compile(inlineCommentPrefix).matcher(file.getContent());
+                while (matcher.find()) {
+                    int start = matcher.start();
+                    inlineComments.add(new IntRange(start, file.getLineBreaks().get(file.getLineNumberOfAbsoluteCharacterIndex(start)).intValue()));
+                }
+            }
+            commentStyle.getInlinePatterns().forEach(it -> {
+                Matcher matcher = Pattern.compile(it.getPattern(), it.createModifier()).matcher(file.getContent());
+                while (matcher.find()) {
+                    int start = matcher.start();
+                    inlineComments.add(new IntRange(start, file.getLineBreaks().get(file.getLineNumberOfAbsoluteCharacterIndex(start)).intValue()));
+                }
+            });
+        }
+
+        return inlineComments;
+    }
+
+    private Comment getCommentForFile(InsiderFile file) {
+        List<String> languages = LinguistService.getInstance().getLanguagesForFile(file);
+
+        return comments.stream().filter(comment -> comment.getLanguages().stream().anyMatch(languages::contains)).findFirst().orElse(null);
+    }
+
+    public List<IntRange> extractMultilineCommentLines(InsiderFile file) {
+        List<IntRange> multilineCommentLinePairs = new ArrayList<>();
+
+        Comment commentStyle = getCommentForFile(file);
+        if (commentStyle != null) {
+            String multilineCommentPrefix = commentStyle.getPreffix();
+            String multilineCommentSuffix = commentStyle.getSuffix();
+            if (multilineCommentPrefix != null && multilineCommentSuffix != null) {
+                List<IntRange> enclosingQuotes = new ArrayList<>();
+                String content = file.getContent();
+
+                List<Integer> quotesIndex = getIndexesForSubstring(file.getContent(), "\"");
+                if (quotesIndex.size() % 2 == 0) {
+                    for (int i = 0; i < quotesIndex.size(); i += 2) {
+                        enclosingQuotes.add(new IntRange(quotesIndex.get(i), quotesIndex.get(i + 1)));
+                    }
+                } else {
+                    log.warn("Could not get Quotes because we found odd number of quotes in file: " + file.getPath());
+                }
+
+                List<Integer> prefixCommentIndexes = getIndexesForSubstring(content, "/*").stream()
+                        .filter(index -> isNotInQuotes(index, enclosingQuotes))
+                        .collect(Collectors.toList());
+                List<Integer> suffixCommentIndexes = getIndexesForSubstring(content, "*/").stream()
+                        .filter(index -> isNotInQuotes(index, enclosingQuotes))
+                        .collect(Collectors.toList());
+
+                if (prefixCommentIndexes.size() != suffixCommentIndexes.size()) {
+                    log.warn("Comments not well matched for file: " + file.getPath() + "!\nPrefix indexes: " + prefixCommentIndexes + "\nSuffix indexes: " + suffixCommentIndexes);
+                }
+                for (int i = 0; i < Math.min(prefixCommentIndexes.size(), suffixCommentIndexes.size()); i++) {
+                    multilineCommentLinePairs.add(new IntRange(prefixCommentIndexes.get(i), suffixCommentIndexes.get(i)));
+                }
+            }
+        }
+        return multilineCommentLinePairs;
+    }
+
+    private boolean isNotInQuotes(Integer index, List<IntRange> enclosingQuotes) {
+        return enclosingQuotes.stream().anyMatch(interval -> interval.containsInteger(index));
+    }
+
+    private List<Integer> getIndexesForSubstring(String content, String substring) {
+        List<Integer> globalIndexes = new ArrayList<>();
+        int index = 0;
+        while (index != -1) {
+            index = content.indexOf(substring, index);
+            if (index != -1) {
+                if (substring.equals("\"")) {
+                    if (content.charAt(index - 1) == '\'' && content.charAt(index + 1) == '\'');
+                }
+                else if (substring.equals("/*")) {
+                    if (index - 1 == -1) {
+                        globalIndexes.add(index);
+                    }
+                    else if (content.charAt(index - 1) == '"' || content.charAt(index + 1) == '"');
+                }
+                else if (substring.equals("*/")) {
+                    if (index - 1 == -1) {
+                        globalIndexes.add(index);
+                    }
+                    else if (content.charAt(index - 1) == '"' || content.charAt(index + 1) == '"');
+                }
+                else {
+                    globalIndexes.add(index);
+                }
+
+                index++;
+            }
+        }
+        return globalIndexes;
+    }
+
+    private int getBackslashesBeforeQuote(String content, int quoteIndex) {
+        String substringToQuote = content.substring(0, quoteIndex);
+        int numberOfBackslashes = 0;
+        for (int i = substringToQuote.length() - 1; i >= 0; i--) {
+            if (substringToQuote.charAt(i) == '\\')
+                numberOfBackslashes++;
+            else break;
+        }
+        return numberOfBackslashes;
+    }
+}

package/src/main/java/org/dxworks/insider/application/inspector/services/RuleService.java

@@ -0,0 +1,54 @@
+package org.dxworks.insider.application.inspector.services;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.dxworks.insider.application.inspector.dtos.Rule;
+
+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.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Slf4j
+public class RuleService {
+
+    public List<Rule> getRuleFromFiles(List<String> ruleFiles) {
+
+        List<Path> ruleFilePaths = ruleFiles.stream()
+                .map(Paths::get)
+                .flatMap(fileOrFolder -> {
+                    if (Files.isDirectory(fileOrFolder)) {
+                        return getAllRuleFilesFromFolder(fileOrFolder);
+                    } else return Stream.of(fileOrFolder);
+                }).collect(Collectors.toList());
+
+        return ruleFilePaths.stream()
+                .flatMap(ruleFile -> getRulesFromFile(ruleFile).stream())
+                .collect(Collectors.toList());
+    }
+
+    private Stream<Path> getAllRuleFilesFromFolder(Path fileOrFolder) {
+        try {
+            return Files.walk(fileOrFolder).filter(path -> path.getFileName().toString().endsWith(".json"));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return Stream.empty();
+    }
+
+    private List<Rule> getRulesFromFile(Path ruleFilePath) {
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            return objectMapper.readValue(ruleFilePath.toFile(), new TypeReference<>() {
+            });
+        } catch (IOException e) {
+            log.warn("Could not read rule file!", e);
+        }
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,125 @@
+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 org.dxworks.insider.utils.ImportUtils;
+import org.dxworks.insider.utils.LibraryImport;
+import org.dxworks.insider.utils.LibraryImportInOtherTechnology;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.dxworks.insider.constants.InsiderConstants.STARS;
+
+@Slf4j
+public class AddCommand extends ConvertCommand {
+
+    @Override
+    public boolean parse(List<String> args) {
+        return super.parse(args) && sourceFile.endsWith(".csv") && targetFile.endsWith(".json");
+    }
+
+    @Override
+    public void execute(List<InsiderFile> insiderFiles, List<String> args) {
+
+        try {
+            JsonFingerprintParser jsonFingerprintParser = new JsonFingerprintParser();
+            List<Technology> jsonTechnologies = jsonFingerprintParser.parseTechnologiesFile(targetFile);
+
+            JavaLibrariesCsvParser javaLibrariesCsvParser = new JavaLibrariesCsvParser();
+            List<Technology> csvTechnologies = javaLibrariesCsvParser.parseTechnologiesFile(sourceFile);
+
+            List<LibraryImport> importsAddedToExistingTechnology = new ArrayList<>();
+            List<LibraryImport> importsAddedToNewTechnology = new ArrayList<>();
+            List<LibraryImport> identicalImportsAlreadyInFile = new ArrayList<>();
+            List<LibraryImportInOtherTechnology> importsAlreadyInFileWithDifferentTechnology = new ArrayList<>();
+            List<Technology> newlyCreatedTechnologies = new ArrayList<>();
+
+            csvTechnologies.forEach(technology -> {
+                List<String> fingerprints = technology.getFingerprints();
+                fingerprints.forEach(fingerPrint -> {
+                    LibraryImport libraryImport = new LibraryImport(ImportUtils.unwrapImportPackage(fingerPrint), technology.getName());
+                    Technology tech = jsonTechnologies.stream().filter(t -> t.getFingerprints().contains(fingerPrint)).findFirst().orElse(null);
+                    if (tech != null) { //fingerprint already exists in JSON file
+                        if (technology.getName().equalsIgnoreCase(tech.getName())) {
+                            identicalImportsAlreadyInFile.add(libraryImport);
+                            return;
+                        }
+                        importsAlreadyInFileWithDifferentTechnology.add(new LibraryImportInOtherTechnology(ImportUtils.unwrapImportPackage(fingerPrint), technology.getName(), tech.getName()));
+                        return;
+                    }
+                    // fingerprint does not exist
+                    Technology sameTech = jsonTechnologies.stream().filter(t -> t.getName().equalsIgnoreCase(technology.getName())).findFirst().orElse(null);
+                    if (sameTech == null) { //adding to new technology
+                        Technology newTechnology = new Technology(technology.getCategory(), technology.getName(), technology.getLanguages(), technology.getExtensions(), Collections.singletonList(fingerPrint));
+                        newlyCreatedTechnologies.add(newTechnology);
+                        jsonTechnologies.add(newTechnology);
+                        importsAddedToNewTechnology.add(libraryImport);
+                    } else {
+                        List<String> oldFps = sameTech.getFingerprints();
+                        List<String> newFps = new ArrayList<>(oldFps);
+                        newFps.add(fingerPrint);
+                        sameTech.setFingerprints(newFps);
+                        if (newlyCreatedTechnologies.contains(sameTech)) {
+                            importsAddedToNewTechnology.add(libraryImport);
+                        } else {
+                            importsAddedToExistingTechnology.add(libraryImport);
+                        }
+                    }
+                });
+            });
+
+            jsonFingerprintParser.writeTechnologiesToFile(jsonTechnologies, Paths.get(targetFile));
+
+            printFingerPrintReport(identicalImportsAlreadyInFile, "Fingerprints already present in file to the same Technology (No action taken):");
+            printFingerPrintsReport(importsAlreadyInFileWithDifferentTechnology);
+            printFingerPrintReport(importsAddedToNewTechnology, "Fingerprints added to a new Technology:");
+            printFingerPrintReport(importsAddedToExistingTechnology, "Fingerprints added to an existing Technology:");
+        } catch (IOException e) {
+            log.error("Could not transform file!", e);
+        }
+    }
+
+    private void printFingerPrintsReport(List<LibraryImportInOtherTechnology> importsAlreadyInFileWithDifferentTechnology) {
+        System.out.println(STARS);
+        System.out.println("Fingerprints already present in file, but mapped to a different Technology (No action taken):");
+        System.out.println();
+        if (importsAlreadyInFileWithDifferentTechnology.isEmpty())
+            System.out.println("None Detected");
+        else
+            System.out.println(importsAlreadyInFileWithDifferentTechnology.stream()
+                    .map(libraryImport -> "\t" + String.join(", ", libraryImport.get_import(), libraryImport.getLibrary(), libraryImport.getOtherTechnology()))
+                    .collect(Collectors.joining("\n")));
+        System.out.println();
+    }
+
+    private void printFingerPrintReport(List<LibraryImport> identicalImportsAlreadyInFile, String headerMessage) {
+        System.out.println(headerMessage);
+        System.out.println(STARS);
+        System.out.println();
+        if (identicalImportsAlreadyInFile.isEmpty())
+            System.out.println("None Detected");
+        else
+            System.out.println(identicalImportsAlreadyInFile.stream()
+                    .map(libraryImport -> "\t" + String.join(", ", libraryImport.get_import(), libraryImport.getLibrary()))
+                    .collect(Collectors.joining("\n")));
+        System.out.println();
+    }
+
+    @Override
+    public String usage() {
+        return "insider add <path_to_csv> <path_to_json>";
+    }
+
+    @Override
+    public String getName() {
+        return ADD;
+    }
+}

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

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