Add clang-format configuration (#16)

bghgary · web-flow · commit 09c5acc49a6a · 2023-03-20T08:35:34.000-07:00
Formatted `Core` and `Polyfills` folders.
diff --git a/.clang-format b/.clang-format
@@ -0,0 +1,36 @@
+---
+Language: Cpp
+# BasedOnStyle: LLVM
+
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+AlignEscapedNewlines: Left
+BraceWrapping:
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: Always
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: true
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: true
+  BeforeCatch: true
+  BeforeElse: true
+  BeforeWhile: true
+BreakBeforeBraces: Custom
+BreakConstructorInitializers: BeforeComma
+BreakStringLiterals: false
+ColumnLimit: 0
+FixNamespaceComments: false
+IndentCaseLabels: true
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: false
+NamespaceIndentation: All
+ReflowComments: false
+PackConstructorInitializers: Never
+PointerAlignment: Left
+SortIncludes: Never
+SortUsingDeclarations: false
+SpaceAfterTemplateKeyword: false
diff --git a/Core/AppRuntime/Include/Babylon/Dispatchable.h b/Core/AppRuntime/Include/Babylon/Dispatchable.h
@@ -29,7 +29,7 @@ namespace Babylon
         {
         public:
             DispatchableImpl(DispatchableImpl<CallableT, ReturnT(ArgsT...)>&& other) = default;
-        
+
             DispatchableImpl(CallableT&& callable)
                 : m_callable{std::forward<CallableT>(callable)}
             {
diff --git a/Core/AppRuntime/Source/AppRuntime_JSI.cpp b/Core/AppRuntime/Source/AppRuntime_JSI.cpp
@@ -38,7 +38,7 @@ namespace Babylon
         v8runtime::V8RuntimeArgs args{};
         args.inspectorPort = 5643;
         args.foreground_task_runner = std::make_shared<TaskRunnerAdapter>(*m_workQueue);
-        
+
         const auto runtime{v8runtime::makeV8Runtime(std::move(args))};
         const auto env{Napi::Attach<facebook::jsi::Runtime&>(*runtime)};
         Dispatch([&runtime](Napi::Env env) {
diff --git a/Core/AppRuntime/Source/WorkQueue.h b/Core/AppRuntime/Source/WorkQueue.h
@@ -23,13 +23,15 @@ namespace Babylon
             // copyable callable if necessary.
             if constexpr (std::is_copy_constructible<CallableT>::value)
             {
-                m_dispatcher.queue([this, callable = std::move(callable)]()
-                    { Invoke(callable); });
+                m_dispatcher.queue([this, callable = std::move(callable)]() {
+                    Invoke(callable);
+                });
             }
             else
             {
-                m_dispatcher.queue([this, callablePtr = std::make_shared<CallableT>(std::move(callable))]()
-                    { Invoke(*callablePtr); });
+                m_dispatcher.queue([this, callablePtr = std::make_shared<CallableT>(std::move(callable))]() {
+                    Invoke(*callablePtr);
+                });
             }
         }
 
diff --git a/Core/JsRuntime/Include/Babylon/JsRuntime.h b/Core/JsRuntime/Include/Babylon/JsRuntime.h
@@ -14,7 +14,7 @@ namespace Babylon
         {
             friend class JsRuntime;
             static constexpr auto JS_NATIVE_NAME = "_native";
-        
+
         public:
             static Napi::Object GetFromJavaScript(Napi::Env env)
             {
diff --git a/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h b/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h
@@ -19,7 +19,7 @@ namespace Babylon
         template<typename CallableT>
         void operator()(CallableT&& callable) const
         {
-            m_runtime.Dispatch([callable{std::forward<CallableT>(callable)}](Napi::Env){
+            m_runtime.Dispatch([callable{std::forward<CallableT>(callable)}](Napi::Env) {
                 callable();
             });
         }
diff --git a/Core/Node-API/.clang-format b/Core/Node-API/.clang-format
@@ -0,0 +1 @@
+DisableFormat: true
diff --git a/Core/ScriptLoader/Source/ScriptLoader.cpp b/Core/ScriptLoader/Source/ScriptLoader.cpp
@@ -18,12 +18,9 @@ namespace Babylon
             UrlLib::UrlRequest request;
             request.Open(UrlLib::UrlMethod::Get, url);
             request.ResponseType(UrlLib::UrlResponseType::String);
-            m_task = arcana::when_all(m_task, request.SendAsync()).then(arcana::inline_scheduler, arcana::cancellation::none(),
-                [dispatchFunction = m_dispatchFunction, request = std::move(request), url = std::move(url)](auto) mutable
-            {
+            m_task = arcana::when_all(m_task, request.SendAsync()).then(arcana::inline_scheduler, arcana::cancellation::none(), [dispatchFunction = m_dispatchFunction, request = std::move(request), url = std::move(url)](auto) mutable {
                 arcana::task_completion_source<void, std::exception_ptr> taskCompletionSource{};
-                dispatchFunction([taskCompletionSource, request = std::move(request), url = std::move(url)](Napi::Env env) mutable
-                {
+                dispatchFunction([taskCompletionSource, request = std::move(request), url = std::move(url)](Napi::Env env) mutable {
                     Napi::Eval(env, request.ResponseString().data(), url.data());
                     taskCompletionSource.complete();
                 });
@@ -34,31 +31,27 @@ namespace Babylon
         void Eval(std::string source, std::string url)
         {
             m_task = m_task.then(arcana::inline_scheduler, arcana::cancellation::none(),
-                [dispatchFunction = m_dispatchFunction, source = std::move(source), url = std::move(url)](auto) mutable
-            {
-                arcana::task_completion_source<void, std::exception_ptr> taskCompletionSource{};
-                dispatchFunction([taskCompletionSource, source = std::move(source), url = std::move(url)](Napi::Env env) mutable
-                {
-                    Napi::Eval(env, source.data(), url.data());
-                    taskCompletionSource.complete();
+                [dispatchFunction = m_dispatchFunction, source = std::move(source), url = std::move(url)](auto) mutable {
+                    arcana::task_completion_source<void, std::exception_ptr> taskCompletionSource{};
+                    dispatchFunction([taskCompletionSource, source = std::move(source), url = std::move(url)](Napi::Env env) mutable {
+                        Napi::Eval(env, source.data(), url.data());
+                        taskCompletionSource.complete();
+                    });
+                    return taskCompletionSource.as_task();
                 });
-                return taskCompletionSource.as_task();
-            });
         }
 
         void Dispatch(std::function<void(Napi::Env)> callback)
         {
             m_task = m_task.then(arcana::inline_scheduler, arcana::cancellation::none(),
-                [dispatchFunction = m_dispatchFunction, callback = std::move(callback)](auto) mutable
-            {
-                arcana::task_completion_source<void, std::exception_ptr> taskCompletionSource{};
-                dispatchFunction([taskCompletionSource, callback = std::move(callback)](Napi::Env env) mutable
-                {
-                    callback(env);
-                    taskCompletionSource.complete();
+                [dispatchFunction = m_dispatchFunction, callback = std::move(callback)](auto) mutable {
+                    arcana::task_completion_source<void, std::exception_ptr> taskCompletionSource{};
+                    dispatchFunction([taskCompletionSource, callback = std::move(callback)](Napi::Env env) mutable {
+                        callback(env);
+                        taskCompletionSource.complete();
+                    });
+                    return taskCompletionSource.as_task();
                 });
-                return taskCompletionSource.as_task();
-            });
         }
 
     private:
diff --git a/Polyfills/AbortController/Source/AbortController.cpp b/Polyfills/AbortController/Source/AbortController.cpp
@@ -1,6 +1,5 @@
 #include "AbortController.h"
 
-
 namespace Babylon::Polyfills::Internal
 {
     void AbortController::Initialize(Napi::Env env)
@@ -25,12 +24,12 @@ namespace Babylon::Polyfills::Internal
         JsRuntime::NativeObject::GetFromJavaScript(env).Set(JS_ABORT_CONTROLLER_CONSTRUCTOR_NAME, func);
     }
 
-    Napi::Value AbortController::GetSignal(const Napi::CallbackInfo& )
+    Napi::Value AbortController::GetSignal(const Napi::CallbackInfo&)
     {
         return m_signal.Value();
     }
 
-    void AbortController::Abort(const Napi::CallbackInfo& )
+    void AbortController::Abort(const Napi::CallbackInfo&)
     {
         m_signal.Set("aborted", true);
         m_signal.Get("onabort").As<Napi::Function>().Call({});
diff --git a/Polyfills/AbortController/Source/AbortSignal.cpp b/Polyfills/AbortController/Source/AbortSignal.cpp
@@ -46,7 +46,7 @@ namespace Babylon::Polyfills::Internal
         {
             return Napi::Value::From(Env(), Env().Null());
         }
-        
+
         return Napi::Value::From(Env(), m_onabort.Value());
     }
 
diff --git a/Polyfills/AbortController/Source/AbortSignal.h b/Polyfills/AbortController/Source/AbortSignal.h
@@ -13,15 +13,13 @@ namespace Babylon::Polyfills::Internal
     class AbortSignal final : public Napi::ObjectWrap<AbortSignal>
     {
     public:
-
         static constexpr auto JS_ABORT_SIGNAL_CONSTRUCTOR_NAME = "AbortSignal";
 
         static void Initialize(Napi::Env env);
 
         explicit AbortSignal(const Napi::CallbackInfo& info);
 
     private:
-
         Napi::Value GetAborted(const Napi::CallbackInfo& info);
         void SetAborted(const Napi::CallbackInfo&, const Napi::Value& value);
 
diff --git a/Polyfills/Console/Source/Console.cpp b/Polyfills/Console/Source/Console.cpp
@@ -53,15 +53,17 @@ namespace
     void AddMethod(Napi::Object& console, const char* functionName, Babylon::Polyfills::Console::LogLevel logLevel, Babylon::Polyfills::Console::CallbackT callback)
     {
         auto existingFunction = std::make_shared<Napi::FunctionReference>(Napi::Persistent(console.Get(functionName).As<Napi::Function>()));
-        console.Set(functionName, Napi::Function::New(console.Env(), [callback, existingFunction = std::move(existingFunction), logLevel](const Napi::CallbackInfo& info)
-        {
-            InvokeCallback(callback, info, logLevel);
+        console.Set(functionName,
+            Napi::Function::New(
+                console.Env(), [callback, existingFunction = std::move(existingFunction), logLevel](const Napi::CallbackInfo& info) {
+                    InvokeCallback(callback, info, logLevel);
 
-            if (!existingFunction->Value().IsUndefined())
-            {
-                Call(existingFunction->Value(), info);
-            }
-        }, functionName));
+                    if (!existingFunction->Value().IsUndefined())
+                    {
+                        Call(existingFunction->Value(), info);
+                    }
+                },
+                functionName));
     }
 }
 
diff --git a/Polyfills/Scheduling/Source/Scheduling.cpp b/Polyfills/Scheduling/Source/Scheduling.cpp
@@ -7,9 +7,10 @@ namespace
 
     Napi::Value SetTimeout(const Napi::CallbackInfo& info, Babylon::Polyfills::Internal::TimeoutDispatcher& timeoutDispatcher)
     {
-        auto function = info[0].IsFunction()
-            ? std::make_shared<Napi::FunctionReference>(Napi::Persistent(info[0].As<Napi::Function>()))
-            : std::shared_ptr<Napi::FunctionReference>{};
+        auto function =
+            info[0].IsFunction()
+                ? std::make_shared<Napi::FunctionReference>(Napi::Persistent(info[0].As<Napi::Function>()))
+                : std::shared_ptr<Napi::FunctionReference>{};
 
         auto delay = std::chrono::milliseconds{info[1].ToNumber().Int32Value()};
 
@@ -36,15 +37,19 @@ namespace Babylon::Polyfills::Scheduling
         {
             auto timeoutDispatcher = std::make_shared<Internal::TimeoutDispatcher>(JsRuntime::GetFromJavaScript(env));
 
-            global.Set(JS_SET_TIMEOUT_NAME, Napi::Function::New(env, [timeoutDispatcher](const Napi::CallbackInfo& info)
-            {
-                return SetTimeout(info, *timeoutDispatcher);
-            }, JS_SET_TIMEOUT_NAME));
-
-            global.Set(JS_CLEAR_TIMEOUT_NAME, Napi::Function::New(env, [timeoutDispatcher](const Napi::CallbackInfo& info)
-            {
-                ClearTimeout(info, *timeoutDispatcher);
-            }, JS_CLEAR_TIMEOUT_NAME));
+            global.Set(JS_SET_TIMEOUT_NAME,
+                Napi::Function::New(
+                    env, [timeoutDispatcher](const Napi::CallbackInfo& info) {
+                        return SetTimeout(info, *timeoutDispatcher);
+                    },
+                    JS_SET_TIMEOUT_NAME));
+
+            global.Set(JS_CLEAR_TIMEOUT_NAME,
+                Napi::Function::New(
+                    env, [timeoutDispatcher](const Napi::CallbackInfo& info) {
+                        ClearTimeout(info, *timeoutDispatcher);
+                    },
+                    JS_CLEAR_TIMEOUT_NAME));
         }
     }
 }
diff --git a/Polyfills/Scheduling/Source/TimeoutDispatcher.cpp b/Polyfills/Scheduling/Source/TimeoutDispatcher.cpp
@@ -68,7 +68,7 @@ namespace Babylon::Polyfills::Internal
         const auto time = Now() + delay;
         const auto result = m_idMap.insert({id, std::make_unique<Timeout>(id, std::move(function), time)});
         m_timeMap.insert({time, result.first->second.get()});
-    
+
         if (time <= earliestTime)
         {
             m_runtime.Dispatch([this](Napi::Env) {
@@ -159,8 +159,9 @@ namespace Babylon::Polyfills::Internal
     {
         if (function)
         {
-            m_runtime.Dispatch([function = std::move(function)](Napi::Env)
-                { function->Call({}); });
+            m_runtime.Dispatch([function = std::move(function)](Napi::Env) {
+                function->Call({});
+            });
         }
     }
 }
diff --git a/Polyfills/URL/Source/URL.cpp b/Polyfills/URL/Source/URL.cpp
@@ -49,7 +49,7 @@ namespace Babylon::Polyfills::Internal
         resultHref << m_origin;
         resultHref << m_pathname;
 
-        std::string allParams = GetSearchQuery();  
+        std::string allParams = GetSearchQuery();
         resultHref << allParams;
 
         return Napi::Value::From(Env(), resultHref.str());
@@ -79,7 +79,7 @@ namespace Babylon::Polyfills::Internal
     std::string URL::GetSearchQuery()
     {
         auto searchParamsObj = URLSearchParams::Unwrap(m_searchParamsReference.Value());
-        return searchParamsObj->GetAllParams();    
+        return searchParamsObj->GetAllParams();
     }
 
     Napi::Value URL::GetSearchParams(const Napi::CallbackInfo&)
@@ -88,7 +88,7 @@ namespace Babylon::Polyfills::Internal
     }
 
     // TODO current URL constructor is incomplete, it only supports one argument
-    // and the url parsing is limited, this logic should be moved to UrlLib and use platform 
+    // and the url parsing is limited, this logic should be moved to UrlLib and use platform
     // specific functions to parse the URL and get the parts
     URL::URL(const Napi::CallbackInfo& info)
         : Napi::ObjectWrap<URL>{info}
@@ -103,15 +103,14 @@ namespace Babylon::Polyfills::Internal
 
         // Get Position of ? to store search var
         const size_t qIndex = m_href.find_last_of('?');
-        
-        if (qIndex != std::string::npos) 
+
+        if (qIndex != std::string::npos)
         {
             m_search = m_href.substr(qIndex, m_href.size() - qIndex);
         }
 
-
-        // get UrlSearchParams object 
-        const Napi::Object searchParams = info.Env().Global().Get(URLSearchParams::JS_URL_SEARCH_PARAMS_CONSTRUCTOR_NAME).As<Napi::Function>().New({Napi::Value::From(info.Env(), m_search) });
+        // get UrlSearchParams object
+        const Napi::Object searchParams = info.Env().Global().Get(URLSearchParams::JS_URL_SEARCH_PARAMS_CONSTRUCTOR_NAME).As<Napi::Function>().New({Napi::Value::From(info.Env(), m_search)});
         m_searchParamsReference = Napi::Persistent(searchParams);
 
         // Get URL Domain
diff --git a/Polyfills/URL/Source/URLSearchParams.cpp b/Polyfills/URL/Source/URLSearchParams.cpp
diff --git a/Polyfills/XMLHttpRequest/Source/XMLHttpRequest.cpp b/Polyfills/XMLHttpRequest/Source/XMLHttpRequest.cpp

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ namespace Babylon`
`29`	`29`	`{`
`30`	`30`	`public:`
`31`	`31`	`DispatchableImpl(DispatchableImpl<CallableT, ReturnT(ArgsT...)>&& other) = default;`
`32`		`-`
	`32`	`+`
`33`	`33`	`DispatchableImpl(CallableT&& callable)`
`34`	`34`	`: m_callable{std::forward<CallableT>(callable)}`
`35`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,15 @@ namespace Babylon`
`23`	`23`	`// copyable callable if necessary.`
`24`	`24`	`if constexpr (std::is_copy_constructible<CallableT>::value)`
`25`	`25`	`{`
`26`		`- m_dispatcher.queue([this, callable = std::move(callable)]()`
`27`		`- { Invoke(callable); });`
	`26`	`+ m_dispatcher.queue([this, callable = std::move(callable)]() {`
	`27`	`+ Invoke(callable);`
	`28`	`+ });`
`28`	`29`	`}`
`29`	`30`	`else`
`30`	`31`	`{`
`31`		`- m_dispatcher.queue([this, callablePtr = std::make_shared<CallableT>(std::move(callable))]()`
`32`		`- { Invoke(*callablePtr); });`
	`32`	`+ m_dispatcher.queue([this, callablePtr = std::make_shared<CallableT>(std::move(callable))]() {`
	`33`	`+ Invoke(*callablePtr);`
	`34`	`+ });`
`33`	`35`	`}`
`34`	`36`	`}`
`35`	`37`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace Babylon`
`14`	`14`	`{`
`15`	`15`	`friend class JsRuntime;`
`16`	`16`	`static constexpr auto JS_NATIVE_NAME = "_native";`
`17`		`-`
	`17`	`+`
`18`	`18`	`public:`
`19`	`19`	`static Napi::Object GetFromJavaScript(Napi::Env env)`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ namespace Babylon`
`19`	`19`	`template<typename CallableT>`
`20`	`20`	`void operator()(CallableT&& callable) const`
`21`	`21`	`{`
`22`		`- m_runtime.Dispatch([callable{std::forward<CallableT>(callable)}](Napi::Env){`
	`22`	`+ m_runtime.Dispatch([callable{std::forward<CallableT>(callable)}](Napi::Env) {`
`23`	`23`	`callable();`
`24`	`24`	`});`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`#include "AbortController.h"`
`2`	`2`
`3`		`-`
`4`	`3`	`namespace Babylon::Polyfills::Internal`
`5`	`4`	`{`
`6`	`5`	`void AbortController::Initialize(Napi::Env env)`
`@@ -25,12 +24,12 @@ namespace Babylon::Polyfills::Internal`
`25`	`24`	`JsRuntime::NativeObject::GetFromJavaScript(env).Set(JS_ABORT_CONTROLLER_CONSTRUCTOR_NAME, func);`
`26`	`25`	`}`
`27`	`26`
`28`		`- Napi::Value AbortController::GetSignal(const Napi::CallbackInfo& )`
	`27`	`+ Napi::Value AbortController::GetSignal(const Napi::CallbackInfo&)`
`29`	`28`	`{`
`30`	`29`	`return m_signal.Value();`
`31`	`30`	`}`
`32`	`31`
`33`		`- void AbortController::Abort(const Napi::CallbackInfo& )`
	`32`	`+ void AbortController::Abort(const Napi::CallbackInfo&)`
`34`	`33`	`{`
`35`	`34`	`m_signal.Set("aborted", true);`
`36`	`35`	`m_signal.Get("onabort").As<Napi::Function>().Call({});`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ namespace Babylon::Polyfills::Internal`
`46`	`46`	`{`
`47`	`47`	`return Napi::Value::From(Env(), Env().Null());`
`48`	`48`	`}`
`49`		`-`
	`49`	`+`
`50`	`50`	`return Napi::Value::From(Env(), m_onabort.Value());`
`51`	`51`	`}`
`52`	`52`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ namespace Babylon::Polyfills::Internal`
`68`	`68`	`const auto time = Now() + delay;`
`69`	`69`	`const auto result = m_idMap.insert({id, std::make_unique<Timeout>(id, std::move(function), time)});`
`70`	`70`	`m_timeMap.insert({time, result.first->second.get()});`
`71`		`-`
	`71`	`+`
`72`	`72`	`if (time <= earliestTime)`
`73`	`73`	`{`
`74`	`74`	`m_runtime.Dispatch([this](Napi::Env) {`
`@@ -159,8 +159,9 @@ namespace Babylon::Polyfills::Internal`
`159`	`159`	`{`
`160`	`160`	`if (function)`
`161`	`161`	`{`
`162`		`- m_runtime.Dispatch([function = std::move(function)](Napi::Env)`
`163`		`- { function->Call({}); });`
	`162`	`+ m_runtime.Dispatch([function = std::move(function)](Napi::Env) {`
	`163`	`+ function->Call({});`
	`164`	`+ });`
`164`	`165`	`}`
`165`	`166`	`}`
`166`	`167`	`}`