ls command Update

-Handle Usage Pattern: ls [flags] [file/directory]
- Update to Main: Handling only the Command Name & remaining parsing done is respective Command File.

Author: siddhant-vij

src/com/unixtools/Main.java

@@ -1,8 +1,5 @@
 package com.unixtools;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import com.unixtools.core.CommandExecutor;
 
 public class Main {
@@ -13,19 +10,8 @@ public static void main(String[] args) {
     }
 
     String commandName = args[0];
-    List<String> commandArgsList = new ArrayList<>();
-
-    for (int i = 1; i < args.length; i++) {
-      if (args[i].startsWith("-") && args[i].length() > 1) {
-        for (int j = 1; j < args[i].length(); j++) {
-          commandArgsList.add("-" + args[i].charAt(j));
-        }
-      } else {
-        commandArgsList.add(args[i]);
-      }
-    }
-
-    String[] commandArgs = commandArgsList.toArray(new String[0]);
+    String[] commandArgs = new String[args.length - 1];
+    System.arraycopy(args, 1, commandArgs, 0, args.length - 1);
 
     CommandExecutor executor = new CommandExecutor();
     executor.executeCommand(commandName, commandArgs);

src/com/unixtools/command/filemanagement/LsCommand.java

@@ -1,53 +1,104 @@
 package com.unixtools.command.filemanagement;
 
+import com.unixtools.core.Command;
+
 import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.text.SimpleDateFormat;
-import java.util.Arrays;
+import java.util.ArrayList;
 import java.util.List;
 
-import com.unixtools.core.Command;
-
 public class LsCommand implements Command {
-  private static final String VALID_FLAGS = "-a, -l, -R";
+  private static final String VALID_FLAGS = "alR";
 
   @Override
   public void execute(String[] args) {
-    List<String> arguments = Arrays.asList(args);
-    if (!arguments.stream().allMatch(arg -> arg.equals("-a") || arg.equals("-l") || arg.equals("-R"))) {
+    List<String> flags = new ArrayList<>();
+    String path = parseArguments(args, flags);
+
+    if (!validateFlags(flags)) {
       System.out.println("Invalid flag(s). Valid flags are: " + VALID_FLAGS);
       return;
     }
 
-    File currentDir = new File(".");
-    processDirectory(currentDir, arguments, 0, "");
+    File directory = validatePath(path);
+    if (directory == null)
+      return;
+
+    processDirectory(directory, flags, 0, "");
   }
 
-  private void processDirectory(File dir, List<String> arguments, int level, String prefix) {
-    boolean longListing = arguments.contains("-l");
-    boolean recursive = arguments.contains("-R");
+  private String parseArguments(String[] args, List<String> flags) {
+    String path = ".";
+    for (String arg : args) {
+      if (arg.startsWith("-")) {
+        for (char flag : arg.substring(1).toCharArray()) {
+          flags.add(String.valueOf(flag));
+        }
+      } else {
+        path = normalizePath(arg);
+        break;
+      }
+    }
+    return path;
+  }
 
-    File[] filesList = dir.listFiles(file -> arguments.contains("-a") || !file.isHidden());
-    if (filesList == null || filesList.length == 0) {
-      if (level == 0) {
-        System.out.println("..");
+  private String normalizePath(String path) {
+    String normalizedPath = path.replace("\\", "/");
+    Path pathObj = Paths.get(normalizedPath).normalize();
+    return pathObj.toString();
+  }
+
+  private boolean validateFlags(List<String> flags) {
+    for (String flag : flags) {
+      if (!VALID_FLAGS.contains(flag)) {
+        return false;
       }
+    }
+    return true;
+  }
+
+  private File validatePath(String path) {
+    File dir = new File(path);
+    if (!dir.exists()) {
+      System.out.println("The specified directory does not exist.");
+      return null;
+    }
+    if (!dir.isDirectory()) {
+      System.out.println("The specified path is not a directory.");
+      return null;
+    }
+    return dir;
+  }
+
+  private void processDirectory(File dir, List<String> flags, int level, String prefix) {
+    boolean longListing = flags.contains("l");
+    boolean recursive = flags.contains("R");
+
+    File[] filesList = dir.listFiles(file -> flags.contains("a") || !file.isHidden());
+    if (filesList == null || filesList.length == 0) {
+      System.out.println(prefix + "Empty directory.");
       return;
     }
 
     for (int i = 0; i < filesList.length; i++) {
       File file = filesList[i];
-      String connector = (i < filesList.length - 1) ? "├── " : "└── ";
-      String childPrefix = (i < filesList.length - 1) ? "|   " : "    ";
-
-      System.out.print(prefix + connector);
+      printTreeStructure(file, i, filesList.length, prefix);
       printFileInfo(file, longListing);
 
       if (recursive && file.isDirectory()) {
-        processDirectory(file, arguments, level + 1, prefix + childPrefix);
+        String nextPrefix = prefix + (i < filesList.length - 1 ? "|   " : "    ");
+        processDirectory(file, flags, level + 1, nextPrefix);
       }
     }
   }
 
+  private void printTreeStructure(File file, int index, int total, String prefix) {
+    String connector = (index < total - 1) ? "├── " : "└── ";
+    System.out.print(prefix + connector);
+  }
+
   private void printFileInfo(File file, boolean longListing) {
     if (longListing) {
       SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
@@ -56,4 +107,4 @@ private void printFileInfo(File file, boolean longListing) {
       System.out.println(file.getName());
     }
   }
-}
+}