ls: Sort displayed entries

apps/ls.cpp

@@ -1,4 +1,6 @@
 #include <grp.h>
+#include <luna/Sort.h>
+#include <luna/StringBuilder.h>
 #include <luna/Units.h>
 #include <os/ArgumentParser.h>
 #include <os/Directory.h>
@@ -20,6 +22,48 @@ void find_user_and_group(struct stat& st, StringView& owner, StringView& group)
         group = grp->gr_name;
 }
 
+int sort_name(const os::Directory::Entry* a, const os::Directory::Entry* b)
+{
+    return String::compare(&a->name, &b->name);
+}
+
+int sort_size(const os::Directory::Entry* a, const os::Directory::Entry* b)
+{
+    return (a->size < b->size) ? -1 : ((a->size == b->size) ? 0 : 1);
+}
+
+int sort_time(const os::Directory::Entry* a, const os::Directory::Entry* b)
+{
+    return (a->mtime < b->mtime) ? -1 : ((a->mtime == b->mtime) ? 0 : 1);
+}
+
+static int (*sort_function)(const os::Directory::Entry*, const os::Directory::Entry*) = sort_name;
+
+int sort_reverse(const os::Directory::Entry* a, const os::Directory::Entry* b)
+{
+    int rc = sort_function(a, b);
+    if (rc < 0) return 1;
+    if (rc > 0) return -1;
+    return 0;
+}
+
+static Result<String> entry_join(const Vector<os::Directory::Entry>& vec, StringView delim)
+{
+    if (vec.size() == 0) return String {};
+    if (vec.size() == 1) return vec[0].name.clone();
+
+    StringBuilder sb;
+    TRY(sb.add(vec[0].name));
+
+    for (usize i = 1; i < vec.size(); i++)
+    {
+        TRY(sb.add(delim));
+        TRY(sb.add(vec[i].name));
+    }
+
+    return sb.string();
+}
+
 Result<int> luna_main(int argc, char** argv)
 {
     StringView pathname;
@@ -32,6 +76,12 @@ Result<int> luna_main(int argc, char** argv)
     bool one_per_line { false };
     bool list_directories { false };
 
+    StringView sort_type { "name" };
+
+    bool reverse_sort { false };
+
+    bool should_sort { true };
+
     os::ArgumentParser parser;
     parser.add_description("List files contained in a directory (defaults to '.', the current directory)"_sv);
     parser.add_system_program_info("ls"_sv);
@@ -46,14 +96,26 @@ Result<int> luna_main(int argc, char** argv)
                                "follow symbolic links listed as arguments"_sv);
     parser.add_switch_argument(one_per_line, '1', ""_sv, "list one file per line"_sv);
     parser.add_switch_argument(list_directories, 'd', "directory"_sv, "list directories instead of their contents"_sv);
+    parser.add_value_argument(sort_type, ' ', "sort"_sv, true, "sort by name, size or time"_sv);
+    parser.add_switch_argument(reverse_sort, 'r', "reverse"_sv, "reverse order while sorting"_sv);
     parser.parse(argc, argv);
 
-    Vector<String> files;
+    Vector<os::Directory::Entry> files;
     int dirfd = AT_FDCWD;
     SharedPtr<os::Directory> dir;
 
     if (!long_list) follow_symlink_args = true;
 
+    if (sort_type == "none"_sv) { should_sort = false; }
+    else if (sort_type == "name"_sv) { sort_function = sort_name; }
+    else if (sort_type == "size"_sv) { sort_function = sort_size; }
+    else if (sort_type == "time"_sv) { sort_function = sort_time; }
+    else
+    {
+        os::eprintln("%s: unknown sort type: %s", argv[0], sort_type.chars());
+        return 1;
+    }
+
     if (os::FileSystem::is_directory(pathname, follow_symlink_args) && !list_directories)
     {
         dir = TRY(os::Directory::open(pathname));
@@ -68,15 +130,31 @@ Result<int> luna_main(int argc, char** argv)
     }
     else if (os::FileSystem::exists(pathname, follow_symlink_args))
     {
-        auto str = TRY(String::from_string_view(pathname));
-        TRY(files.try_append(move(str)));
+        struct stat st;
+        TRY(os::FileSystem::stat(pathname, st, false));
+
+        os::Directory::Entry entry = {
+            .name = TRY(String::from_string_view(pathname)),
+            .mode = st.st_mode,
+            .size = (usize)st.st_size,
+            .mtime = st.st_mtime,
+        };
+
+        TRY(files.try_append(move(entry)));
     }
     else
         return err(ENOENT);
 
+    if (should_sort)
+    {
+        if (reverse_sort) sort(files.begin(), files.end(), sort_reverse);
+        else
+            sort(files.begin(), files.end(), sort_function);
+    }
+
     if (!long_list)
     {
-        auto list = TRY(String::join(files, one_per_line ? "\n"_sv : " "_sv));
+        auto list = TRY(entry_join(files, one_per_line ? "\n"_sv : " "_sv));
         if (!list.is_empty()) os::println("%s", list.chars());
     }
     else
@@ -84,9 +162,9 @@ Result<int> luna_main(int argc, char** argv)
         for (const auto& file : files)
         {
             struct stat st;
-            TRY(os::FileSystem::stat({ dirfd, file.view() }, st, false));
+            TRY(os::FileSystem::stat({ dirfd, file.name.view() }, st, false));
 
-            auto link = TRY(os::FileSystem::readlink({ dirfd, file.view() }));
+            auto link = TRY(os::FileSystem::readlink({ dirfd, file.name.view() }));
 
             StringView owner;
             StringView group;
@@ -99,13 +177,13 @@ Result<int> luna_main(int argc, char** argv)
             if (!human_readable && !si)
             {
                 os::println("%s %u %4s %4s %10lu %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
-                            st.st_size, file.chars(), link.is_empty() ? "" : " -> ", link.chars());
+                            st.st_size, file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
             }
             else
             {
                 auto size = TRY(to_dynamic_unit(st.st_size, 10, false, si ? Unit::SI : Unit::Binary, false));
                 os::println("%s %u %4s %4s %6s %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
-                            size.chars(), file.chars(), link.is_empty() ? "" : " -> ", link.chars());
+                            size.chars(), file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
             }
         }
     }