basic query lang done

querylanguagecommands

+comments
+---------
+show issue with "string" contained/not contained in comments comment:"string"
+
+tags
+------
+show issues with "tag" tag:"tag"
+
+
+assignees
+watchers
+creator
+----------
+show issues with user attached as commenter/assignee/watcher/creator
+
+X:<[name] || [email]>
+
+
+title
+------
+show issue with title "title"
+
+
+description
+-----------
+show issue with desc containing "desc"
+
+
+status
+------
+show issue with status "status"
+
+
+creation time
+edited time
+--------------
+show with time >, <, >=, <= date

questions

@@ -4,12 +4,11 @@ edit comments
 
 query language - search syntax
 hook when someone assigns an issue and i pull notify me of new issues
-add watching, notify when closed
+notify watchers when closed
 
 when github central server gets pushed send emails, subscribers get emailed, post/recieve hook on central that uses program to search for subsribers
 
 edit time on merge
 
 truncate the input
-
-filter comments by time
\ No newline at end of file
+media
\ No newline at end of file

src/main/java/cli/CommandLineInterface.java

@@ -59,7 +59,7 @@ public class CommandLineInterface {
                 .desc("list issues")
                 .hasArgs()
                 .optionalArg(true)
-                .argName("ls")
+                .argName("QUERY")
                 .build();
 
         uniqueCommands.addOption(ls);
@@ -122,7 +122,7 @@ public class CommandLineInterface {
 
     public void help() {
         HelpFormatter formatter = new HelpFormatter();
-        formatter.printHelp("git ddit --<command> [args]", options);
+        formatter.printHelp("Use quotation marks for args with whitespace \ngit ddit --<command> [args]", options);
     }
 
     public CommandLine getInput(String[] userInput) throws ParseException {

src/main/java/command/CommandAssign.java

@@ -5,7 +5,7 @@ import issueData.User;
 
 import java.io.IOException;
 
-public class CommandAssign implements Command {
+public final class CommandAssign implements Command {
 
     private final String hash;
     private final String option;

src/main/java/command/CommandLs.java

 package command;
 
 import git.IssueRepo;
+import queries.FilterIssues;
 
 public final class CommandLs implements Command {
 
@@ -12,26 +13,34 @@ public final class CommandLs implements Command {
 
     @Override
     public void execute() {
+
         IssueRepo repo = new IssueRepo();
 
-        if (args.length == 0) {
+        if(args == null){
             repo.getIssues().forEach(System.out::println);
-        } else if (args[0].equals("closed")) {
-            repo.getIssues().forEach(issue -> {
-                if (!issue.isOpen()) {
-                    System.out.println(issue);
-                }
-            });
-        } else if (args[0].equals("user") && args[1] != null) {
-            repo.getIssues().forEach(issue -> {
-                if (issue.getCreator().name.contains(args[1]) || issue.getCreator().email.contains(args[1])) {
-                    System.out.println(issue);
-                }
-            });
         } else {
-            System.out.println("Invalid options given, defaulting to showing open issues");
-            repo.getIssues().forEach(System.out::println);
+            FilterIssues filterIssues = new FilterIssues(args, repo.getIssues());
+            filterIssues.filter().forEach(System.out::println);
         }
 
+//        if (args.length == 0) {
+//            repo.getIssues().forEach(System.out::println);
+//        } else if (args[0].equals("closed")) {
+//            repo.getIssues().forEach(issue -> {
+//                if (!issue.isOpen()) {
+//                    System.out.println(issue);
+//                }
+//            });
+//        } else if (args[0].equals("user") && args[1] != null) {
+//            repo.getIssues().forEach(issue -> {
+//                if (issue.getCreator().name.contains(args[1]) || issue.getCreator().email.contains(args[1])) {
+//                    System.out.println(issue);
+//                }
+//            });
+//        } else {
+//            System.out.println("Invalid options given, defaulting to showing open issues");
+//            repo.getIssues().forEach(System.out::println);
+//        }
+
     }
 }

src/main/java/command/CommandShow.java

 package command;
 
 import git.IssueRepo;
+import issueData.Comment;
+import issueData.Issue;
+
+import java.util.Comparator;
+import java.util.List;
 
 public final class CommandShow implements Command {
 
@@ -40,8 +45,10 @@ public final class CommandShow implements Command {
                 if (issue.getComments().isEmpty()) {
                     System.out.println("\nNo comments on this issue");
                 } else {
+                    List<Comment> sortedComments = issue.getComments();
+                    sortedComments.sort(Comparator.comparing(Comment::getCreationTime));
                     System.out.println("\nComments:\n");
-                    issue.getComments().forEach(comment -> System.out.println("Author: " + comment.getAuthor() + "\n" + comment.getMessage() + "\n"));
+                    sortedComments.forEach(comment -> System.out.println("Author: " + comment.getAuthor() + "\n" + comment.getMessage() + "\n"));
                 }
 
             }

src/main/java/command/CommandWatcher.java

@@ -5,7 +5,7 @@ import issueData.User;
 
 import java.io.IOException;
 
-public class CommandWatcher implements Command {
+public final class CommandWatcher implements Command {
 
     private final String hash;
     private final String option;

src/main/java/queries/FilterIssues.java

+package queries;
+
+import issueData.Issue;
+import issueData.User;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class FilterIssues {
+
+    private Map<String, String> conditions;
+    private List<Issue> issueList;
+
+    public FilterIssues(String[] query, List<Issue> issueList) {
+        ParseQuery parseQuery = new ParseQuery(query);
+        this.conditions = parseQuery.getQualifierAndValue();
+        this.issueList = issueList;
+    }
+
+    public List<Issue> filter() {
+
+        List<Issue> issues = issueList;
+        conditions.forEach((qualifier, value) -> issues.removeIf(issue -> {
+            switch (qualifier) {
+                case "title":
+                    return !issue.getTitle().contains(value);
+                case "comment":
+                    return !commentContains(issue, value);
+                case "tag":
+                    return !issue.getTags().contains(value);
+                case "assignee":
+                    return !userExistInSet(issue.getAssignees(), value);
+                case "watcher":
+                    return !userExistInSet(issue.getWatchers(), value);
+                case "creator":
+                    User user = issue.getCreator();
+                    return !user.name.contains(value) || !user.email.contains(value);
+                case "description":
+                    return !issue.getDescription().contains(value);
+                case "status":
+                    return !value.equals("open");
+                case "created":
+                case "edited":
+
+                default:
+                    return false;
+            }
+
+        }));
+
+        return issues;
+
+    }
+
+
+    private boolean userExistInSet(Set<User> users, String value) {
+        return users.stream().anyMatch(user -> user.name.contains(value) || user.email.contains(value));
+    }
+
+    private boolean commentContains(Issue issue, String value) {
+        return issue.getComments().stream().anyMatch(comment -> comment.getMessage().contains(value));
+    }
+}

src/main/java/queries/ParseQuery.java

+package queries;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ParseQuery {
+
+    private Map<String, String> qualifierAndValue;
+
+    ParseQuery(String[] query) {
+        qualifierAndValue = new HashMap<>();
+        parseConditions(query);
+    }
+
+    Map<String, String> getQualifierAndValue() {
+        return qualifierAndValue;
+    }
+
+    private void parseConditions(String[] query) {
+        for (String condition : query) {
+            String[] splitCondition = condition.split(":");
+            if (splitCondition.length == 2) {
+                qualifierAndValue.put(splitCondition[0].toLowerCase(), splitCondition[1].toLowerCase());
+            } else {
+                System.out.println("Condition: " + condition + " not valid");
+            }
+        }
+    }
+
+
+}