Formatting, and prune unused #includes

src/dds/build.cpp

 #include "./build.hpp"
 
-#include <dds/build/plan/compile_file.hpp>
 #include <dds/compdb.hpp>
 #include <dds/logging.hpp>
-#include <dds/proc.hpp>
-#include <dds/source.hpp>
-#include <dds/toolchain/toolchain.hpp>
 #include <dds/usage_reqs.hpp>
 #include <dds/util/algo.hpp>
-#include <dds/util/string.hpp>
 #include <libman/index.hpp>
 #include <libman/parse.hpp>
 
-#include <range/v3/range/conversion.hpp>
-#include <range/v3/view/drop.hpp>
-#include <range/v3/view/filter.hpp>
-#include <range/v3/view/transform.hpp>
-
-#include <algorithm>
-#include <chrono>
-#include <iomanip>
-#include <iostream>
-#include <mutex>
-#include <sstream>
 #include <stdexcept>
-#include <thread>
 
 using namespace dds;
 
-using namespace ranges;
-using namespace ranges::views;
-
 namespace {
 
 struct archive_failure : std::runtime_error {

src/dds/build.hpp

 
 #include <dds/build/params.hpp>
 #include <dds/package_manifest.hpp>
-#include <dds/util/fs.hpp>
-
-#include <optional>
 
 namespace dds {
 

src/dds/build/archive.cpp

-#include "./archive.hpp"

src/dds/build/archive.hpp

-#pragma once
-
-#include <dds/toolchain/toolchain.hpp>
-#include <dds/util/fs.hpp>
-
-#include <vector>
-
-namespace dds {
-
-struct archive_rules {
-    std::vector<fs::path> objects;
-    fs::path              out;
-
-    void create_archive(const toolchain& tc) const;
-};
-
-}  // namespace dds

src/dds/build/executable.hpp

-#pragma once
-
-#include <dds/util/fs.hpp>
-
-#include <vector>
-
-namespace dds {
-
-class link_executable_rules {
-    std::vector<fs::path> inputs;
-    fs::path              output;
-};
-
-}  // namespace dds

src/dds/build/plan/compile_file.cpp

 
 #include <spdlog/spdlog.h>
 
-#include <atomic>
-#include <mutex>
-#include <thread>
+#include <string>
 #include <vector>
 
 using namespace dds;

src/dds/build/plan/exe.cpp

 #include <spdlog/spdlog.h>
 
 #include <algorithm>
-#include <cassert>
 #include <chrono>
 
 using namespace dds;

src/dds/build/plan/exe.hpp

 #include <dds/build/plan/compile_file.hpp>
 #include <dds/util/fs.hpp>
 
-#include <set>
-#include <tuple>
+#include <string>
 #include <vector>
 
 namespace dds {

src/dds/build/plan/full.cpp

 #include "./full.hpp"
 
 #include <dds/build/iter_compilations.hpp>
-#include <dds/proc.hpp>
 
-#include <range/v3/action/join.hpp>
 #include <range/v3/view/concat.hpp>
 #include <range/v3/view/filter.hpp>
 #include <range/v3/view/join.hpp>
-#include <range/v3/view/repeat_n.hpp>
 #include <range/v3/view/transform.hpp>
-#include <range/v3/view/zip.hpp>
 
 #include <spdlog/spdlog.h>
 
-#include <chrono>
 #include <mutex>
 #include <thread>
 
 }
 
 void build_plan::link_all(const build_env& env, int njobs) const {
-    std::vector<std::pair<std::reference_wrapper<const library_plan>, std::reference_wrapper<const link_executable_plan>>> executables;
+    std::vector<std::pair<std::reference_wrapper<const library_plan>,
+                          std::reference_wrapper<const link_executable_plan>>>
+        executables;
 
     for (auto&& lib : iter_libraries(*this)) {
         for (auto&& exe : lib.executables()) {

src/dds/build/plan/full.hpp

 #pragma once
 
-#include <dds/build/params.hpp>
-#include <dds/build/plan/archive.hpp>
-#include <dds/build/plan/compile_file.hpp>
 #include <dds/build/plan/exe.hpp>
-#include <dds/build/plan/library.hpp>
 #include <dds/build/plan/package.hpp>
-#include <dds/library.hpp>
 
 namespace dds {
 

src/dds/build/plan/library.cpp

 
 #include <range/v3/view/concat.hpp>
 #include <range/v3/view/filter.hpp>
-#include <spdlog/spdlog.h>
 
 using namespace dds;
 

src/dds/build/plan/library.hpp

 #include <dds/usage_reqs.hpp>
 #include <dds/util/fs.hpp>
 
-#include <map>
 #include <optional>
 #include <string>
 #include <vector>

src/dds/build/plan/package.hpp

 
 #include <dds/build/plan/library.hpp>
 
-#include <map>
 #include <string>
+#include <vector>
 
 namespace dds {
 

src/dds/compdb.cpp

 
 #include <nlohmann/json.hpp>
 
-#include <range/v3/view/join.hpp>
-#include <range/v3/view/transform.hpp>
-
 using namespace dds;
 
 void dds::generate_compdb(const build_plan& plan, build_env_ref env) {

src/dds/dds.main.cpp

 #include <range/v3/view/group_by.hpp>
 #include <range/v3/view/transform.hpp>
 
-#include <libman/parse.hpp>
-
 #include <args.hxx>
 
 #include <filesystem>
 */
 
 int main(int argc, char** argv) {
-    #if DDS_DEBUG
+#if DDS_DEBUG
     spdlog::set_level(spdlog::level::debug);
-    #endif
+#endif
     spdlog::set_pattern("[%H:%M:%S] [%^%-5l%$] %v");
     args::ArgumentParser parser("DDS - The drop-dead-simple library manager");
 

src/dds/deps.cpp

 #include <dds/repo/repo.hpp>
 #include <dds/sdist.hpp>
 #include <dds/usage_reqs.hpp>
-#include <dds/util/algo.hpp>
 #include <dds/util/string.hpp>
 #include <libman/index.hpp>
 #include <libman/parse.hpp>
 
 #include <cctype>
 #include <map>
+#include <set>
 
 using namespace dds;
 

src/dds/library.hpp

 #include <dds/library_manifest.hpp>
 #include <dds/source.hpp>
 
-#include <optional>
 #include <string>
 
 namespace dds {

src/dds/proc.common.cpp

 #include <dds/util/string.hpp>
 
 #include <algorithm>
-#include <array>
 #include <cctype>
 
 using namespace dds;

src/dds/repo/repo.cpp

 
 #include <spdlog/spdlog.h>
 
-#include <range/v3/action/join.hpp>
-#include <range/v3/range/conversion.hpp>
 #include <range/v3/view/filter.hpp>
-#include <range/v3/view/join.hpp>
 #include <range/v3/view/transform.hpp>
 
 using namespace dds;

src/dds/repo/repo.hpp

 #include <dds/util/flock.hpp>
 #include <dds/util/fs.hpp>
 
-#include <cassert>
 #include <functional>
 #include <optional>
 #include <shared_mutex>

src/dds/sdist.cpp

 #include <browns/output.hpp>
 #include <neo/buffer.hpp>
 
-#include <range/v3/algorithm/for_each.hpp>
 #include <range/v3/algorithm/sort.hpp>
 #include <range/v3/view/filter.hpp>
 

src/dds/source.cpp

 
 #include <dds/util/string.hpp>
 
-#include <spdlog/spdlog.h>
-
 #include <algorithm>
 #include <optional>
 #include <vector>

src/dds/source.hpp

 #include <dds/util/fs.hpp>
 
 #include <optional>
-#include <vector>
 
 namespace dds {
 

src/dds/toolchain/toolchain.hpp

 
 #include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace dds {

src/libman/parse.hpp

 void validate_reader(T&&, std::string_view, ...) {}
 
 template <typename... Items>
-auto read(std::string_view context[[maybe_unused]], const pair_list& pairs, Items... is) {
+auto read(std::string_view context [[maybe_unused]], const pair_list& pairs, Items... is) {
     std::vector<pair> bad_pairs;
     for (auto [key, value] : pairs.items()) {
         auto did_read = (is(context, key, value) || ...);