| [0c6b92a] | 1 | #! /usr/bin/env node
|
|---|
| 2 |
|
|---|
| 3 | 'use strict';
|
|---|
| 4 |
|
|---|
| 5 | const fs = require('fs');
|
|---|
| 6 | const path = require('path');
|
|---|
| 7 |
|
|---|
| 8 | const args = process.argv.slice(2);
|
|---|
| 9 | const dir = args[0];
|
|---|
| 10 | if (!dir) {
|
|---|
| 11 | console.log('Usage: node ' + path.basename(__filename) + ' <target-dir>');
|
|---|
| 12 | process.exit(1);
|
|---|
| 13 | }
|
|---|
| 14 |
|
|---|
| 15 | const NodeApiVersion = require('../package.json').version;
|
|---|
| 16 |
|
|---|
| 17 | const disable = args[1];
|
|---|
| 18 | let ConfigFileOperations;
|
|---|
| 19 | if (disable !== '--disable' && dir !== '--disable') {
|
|---|
| 20 | ConfigFileOperations = {
|
|---|
| 21 | 'package.json': [
|
|---|
| 22 | [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1 "node-addon-api": "' + NodeApiVersion + '",'],
|
|---|
| 23 | [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '']
|
|---|
| 24 | ],
|
|---|
| 25 | 'binding.gyp': [
|
|---|
| 26 | [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1 \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\','],
|
|---|
| 27 | [/([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1 "<!(node -p \\"require(\'node-addon-api\').include_dir\\")",'],
|
|---|
| 28 | [/[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, ''],
|
|---|
| 29 | [/([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n $2cflags!$2: [ $2-fno-exceptions$2 ],\n $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n $2xcode_settings$2: { $2GCC_ENABLE_CPP_EXCEPTIONS$2: $2YES$2,\n $2CLANG_CXX_LIBRARY$2: $2libc++$2,\n $2MACOSX_DEPLOYMENT_TARGET$2: $210.7$2,\n },\n $2msvs_settings$2: {\n $2VCCLCompilerTool$2: { $2ExceptionHandling$2: 1 },\n },']
|
|---|
| 30 | ]
|
|---|
| 31 | };
|
|---|
| 32 | } else {
|
|---|
| 33 | ConfigFileOperations = {
|
|---|
| 34 | 'package.json': [
|
|---|
| 35 | [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1 "node-addon-api": "' + NodeApiVersion + '",'],
|
|---|
| 36 | [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '']
|
|---|
| 37 | ],
|
|---|
| 38 | 'binding.gyp': [
|
|---|
| 39 | [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1 \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\','],
|
|---|
| 40 | [/([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1 "<!(node -p \'require(\\"node-addon-api\\").include_dir\')",'],
|
|---|
| 41 | [/[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, ''],
|
|---|
| 42 | [/([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n $2cflags!$2: [ $2-fno-exceptions$2 ],\n $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n $2defines$2: [ $2NAPI_DISABLE_CPP_EXCEPTIONS$2 ],\n $2conditions$2: [\n [\'OS=="win"\', { $2defines$2: [ $2_HAS_EXCEPTIONS=1$2 ] }]\n ]']
|
|---|
| 43 | ]
|
|---|
| 44 | };
|
|---|
| 45 | }
|
|---|
| 46 |
|
|---|
| 47 | const SourceFileOperations = [
|
|---|
| 48 | [/Nan::SetMethod\(target,[\s]*"(.*)"[\s]*,[\s]*([^)]+)\)/g, 'exports.Set(Napi::String::New(env, "$1"), Napi::Function::New(env, $2))'],
|
|---|
| 49 |
|
|---|
| 50 | [/v8::Local<v8::FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'],
|
|---|
| 51 | [/Local<FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);\s+(\w+)\.Reset\((\1)\);\s+\1->SetClassName\((Nan::String::New|Nan::New<(v8::)*String>)\("(.+?)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$6", {'],
|
|---|
| 52 | [/Local<FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'],
|
|---|
| 53 | [/Nan::New<v8::FunctionTemplate>\(([\w\d:]+)\)->GetFunction\(\)/g, 'Napi::Function::New(env, $1)'],
|
|---|
| 54 | [/Nan::New<FunctionTemplate>\(([\w\d:]+)\)->GetFunction()/g, 'Napi::Function::New(env, $1);'],
|
|---|
| 55 | [/Nan::New<v8::FunctionTemplate>\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'],
|
|---|
| 56 | [/Nan::New<FunctionTemplate>\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'],
|
|---|
| 57 |
|
|---|
| 58 | // FunctionTemplate to FunctionReference
|
|---|
| 59 | [/Nan::Persistent<(v8::)*FunctionTemplate>/g, 'Napi::FunctionReference'],
|
|---|
| 60 | [/Nan::Persistent<(v8::)*Function>/g, 'Napi::FunctionReference'],
|
|---|
| 61 | [/v8::Local<v8::FunctionTemplate>/g, 'Napi::FunctionReference'],
|
|---|
| 62 | [/Local<FunctionTemplate>/g, 'Napi::FunctionReference'],
|
|---|
| 63 | [/v8::FunctionTemplate/g, 'Napi::FunctionReference'],
|
|---|
| 64 | [/FunctionTemplate/g, 'Napi::FunctionReference'],
|
|---|
| 65 |
|
|---|
| 66 | [/([ ]*)Nan::SetPrototypeMethod\(\w+, "(\w+)", (\w+)\);/g, '$1InstanceMethod("$2", &$3),'],
|
|---|
| 67 | [/([ ]*)(?:\w+\.Reset\(\w+\);\s+)?\(target\)\.Set\("(\w+)",\s*Nan::GetFunction\((\w+)\)\);/gm,
|
|---|
| 68 | '});\n\n' +
|
|---|
| 69 | '$1constructor = Napi::Persistent($3);\n' +
|
|---|
| 70 | '$1constructor.SuppressDestruct();\n' +
|
|---|
| 71 | '$1target.Set("$2", $3);'],
|
|---|
| 72 |
|
|---|
| 73 | // TODO: Other attribute combinations
|
|---|
| 74 | [/static_cast<PropertyAttribute>\(ReadOnly\s*\|\s*DontDelete\)/gm,
|
|---|
| 75 | 'static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)'],
|
|---|
| 76 |
|
|---|
| 77 | [/([\w\d:<>]+?)::Cast\((.+?)\)/g, '$2.As<$1>()'],
|
|---|
| 78 |
|
|---|
| 79 | [/\*Nan::Utf8String\(([^)]+)\)/g, '$1->As<Napi::String>().Utf8Value().c_str()'],
|
|---|
| 80 | [/Nan::Utf8String +(\w+)\(([^)]+)\)/g, 'std::string $1 = $2.As<Napi::String>()'],
|
|---|
| 81 | [/Nan::Utf8String/g, 'std::string'],
|
|---|
| 82 |
|
|---|
| 83 | [/v8::String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'],
|
|---|
| 84 | [/String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'],
|
|---|
| 85 | [/\.length\(\)/g, '.Length()'],
|
|---|
| 86 |
|
|---|
| 87 | [/Nan::MakeCallback\(([^,]+),[\s\\]+([^,]+),/gm, '$2.MakeCallback($1,'],
|
|---|
| 88 |
|
|---|
| 89 | [/class\s+(\w+)\s*:\s*public\s+Nan::ObjectWrap/g, 'class $1 : public Napi::ObjectWrap<$1>'],
|
|---|
| 90 | [/(\w+)\(([^)]*)\)\s*:\s*Nan::ObjectWrap\(\)\s*(,)?/gm, '$1($2) : Napi::ObjectWrap<$1>()$3'],
|
|---|
| 91 |
|
|---|
| 92 | // HandleOKCallback to OnOK
|
|---|
| 93 | [/HandleOKCallback/g, 'OnOK'],
|
|---|
| 94 | // HandleErrorCallback to OnError
|
|---|
| 95 | [/HandleErrorCallback/g, 'OnError'],
|
|---|
| 96 |
|
|---|
| 97 | // ex. .As<Function>() to .As<Napi::Object>()
|
|---|
| 98 | [/\.As<v8::(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As<Napi::$1>()'],
|
|---|
| 99 | [/\.As<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As<Napi::$1>()'],
|
|---|
| 100 |
|
|---|
| 101 | // ex. Nan::New<Number>(info[0]) to Napi::Number::New(info[0])
|
|---|
| 102 | [/Nan::New<(v8::)*Integer>\((.+?)\)/g, 'Napi::Number::New(env, $2)'],
|
|---|
| 103 | [/Nan::New\(([0-9.]+)\)/g, 'Napi::Number::New(env, $1)'],
|
|---|
| 104 | [/Nan::New<(v8::)*String>\("(.+?)"\)/g, 'Napi::String::New(env, "$2")'],
|
|---|
| 105 | [/Nan::New\("(.+?)"\)/g, 'Napi::String::New(env, "$1")'],
|
|---|
| 106 | [/Nan::New<(v8::)*(.+?)>\(\)/g, 'Napi::$2::New(env)'],
|
|---|
| 107 | [/Nan::New<(.+?)>\(\)/g, 'Napi::$1::New(env)'],
|
|---|
| 108 | [/Nan::New<(v8::)*(.+?)>\(/g, 'Napi::$2::New(env, '],
|
|---|
| 109 | [/Nan::New<(.+?)>\(/g, 'Napi::$1::New(env, '],
|
|---|
| 110 | [/Nan::NewBuffer\(/g, 'Napi::Buffer<char>::New(env, '],
|
|---|
| 111 | // TODO: Properly handle this
|
|---|
| 112 | [/Nan::New\(/g, 'Napi::New(env, '],
|
|---|
| 113 |
|
|---|
| 114 | [/\.IsInt32\(\)/g, '.IsNumber()'],
|
|---|
| 115 | [/->IsInt32\(\)/g, '.IsNumber()'],
|
|---|
| 116 |
|
|---|
| 117 | [/(.+?)->BooleanValue\(\)/g, '$1.As<Napi::Boolean>().Value()'],
|
|---|
| 118 | [/(.+?)->Int32Value\(\)/g, '$1.As<Napi::Number>().Int32Value()'],
|
|---|
| 119 | [/(.+?)->Uint32Value\(\)/g, '$1.As<Napi::Number>().Uint32Value()'],
|
|---|
| 120 | [/(.+?)->IntegerValue\(\)/g, '$1.As<Napi::Number>().Int64Value()'],
|
|---|
| 121 | [/(.+?)->NumberValue\(\)/g, '$1.As<Napi::Number>().DoubleValue()'],
|
|---|
| 122 |
|
|---|
| 123 | // ex. Nan::To<bool>(info[0]) to info[0].Value()
|
|---|
| 124 | [/Nan::To<v8::(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To<Napi::$1>()'],
|
|---|
| 125 | [/Nan::To<(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To<Napi::$1>()'],
|
|---|
| 126 | // ex. Nan::To<bool>(info[0]) to info[0].As<Napi::Boolean>().Value()
|
|---|
| 127 | [/Nan::To<bool>\((.+?)\)/g, '$1.As<Napi::Boolean>().Value()'],
|
|---|
| 128 | // ex. Nan::To<int>(info[0]) to info[0].As<Napi::Number>().Int32Value()
|
|---|
| 129 | [/Nan::To<int>\((.+?)\)/g, '$1.As<Napi::Number>().Int32Value()'],
|
|---|
| 130 | // ex. Nan::To<int32_t>(info[0]) to info[0].As<Napi::Number>().Int32Value()
|
|---|
| 131 | [/Nan::To<int32_t>\((.+?)\)/g, '$1.As<Napi::Number>().Int32Value()'],
|
|---|
| 132 | // ex. Nan::To<uint32_t>(info[0]) to info[0].As<Napi::Number>().Uint32Value()
|
|---|
| 133 | [/Nan::To<uint32_t>\((.+?)\)/g, '$1.As<Napi::Number>().Uint32Value()'],
|
|---|
| 134 | // ex. Nan::To<int64_t>(info[0]) to info[0].As<Napi::Number>().Int64Value()
|
|---|
| 135 | [/Nan::To<int64_t>\((.+?)\)/g, '$1.As<Napi::Number>().Int64Value()'],
|
|---|
| 136 | // ex. Nan::To<float>(info[0]) to info[0].As<Napi::Number>().FloatValue()
|
|---|
| 137 | [/Nan::To<float>\((.+?)\)/g, '$1.As<Napi::Number>().FloatValue()'],
|
|---|
| 138 | // ex. Nan::To<double>(info[0]) to info[0].As<Napi::Number>().DoubleValue()
|
|---|
| 139 | [/Nan::To<double>\((.+?)\)/g, '$1.As<Napi::Number>().DoubleValue()'],
|
|---|
| 140 |
|
|---|
| 141 | [/Nan::New\((\w+)\)->HasInstance\((\w+)\)/g, '$2.InstanceOf($1.Value())'],
|
|---|
| 142 |
|
|---|
| 143 | [/Nan::Has\(([^,]+),\s*/gm, '($1).Has('],
|
|---|
| 144 | [/\.Has\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Has($1)'],
|
|---|
| 145 | [/\.Has\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Has($1)'],
|
|---|
| 146 |
|
|---|
| 147 | [/Nan::Get\(([^,]+),\s*/gm, '($1).Get('],
|
|---|
| 148 | [/\.Get\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Get($1)'],
|
|---|
| 149 | [/\.Get\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Get($1)'],
|
|---|
| 150 |
|
|---|
| 151 | [/Nan::Set\(([^,]+),\s*/gm, '($1).Set('],
|
|---|
| 152 | [/\.Set\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\s*,/gm, '.Set($1,'],
|
|---|
| 153 | [/\.Set\([\s|\\]*Nan::New\(([^)]+)\)\s*,/gm, '.Set($1,'],
|
|---|
| 154 |
|
|---|
| 155 | // ex. node::Buffer::HasInstance(info[0]) to info[0].IsBuffer()
|
|---|
| 156 | [/node::Buffer::HasInstance\((.+?)\)/g, '$1.IsBuffer()'],
|
|---|
| 157 | // ex. node::Buffer::Length(info[0]) to info[0].Length()
|
|---|
| 158 | [/node::Buffer::Length\((.+?)\)/g, '$1.As<Napi::Buffer<char>>().Length()'],
|
|---|
| 159 | // ex. node::Buffer::Data(info[0]) to info[0].Data()
|
|---|
| 160 | [/node::Buffer::Data\((.+?)\)/g, '$1.As<Napi::Buffer<char>>().Data()'],
|
|---|
| 161 | [/Nan::CopyBuffer\(/g, 'Napi::Buffer::Copy(env, '],
|
|---|
| 162 |
|
|---|
| 163 | // Nan::AsyncQueueWorker(worker)
|
|---|
| 164 | [/Nan::AsyncQueueWorker\((.+)\);/g, '$1.Queue();'],
|
|---|
| 165 | [/Nan::(Undefined|Null|True|False)\(\)/g, 'env.$1()'],
|
|---|
| 166 |
|
|---|
| 167 | // Nan::ThrowError(error) to Napi::Error::New(env, error).ThrowAsJavaScriptException()
|
|---|
| 168 | [/([ ]*)return Nan::Throw(\w*?)Error\((.+?)\);/g, '$1Napi::$2Error::New(env, $3).ThrowAsJavaScriptException();\n$1return env.Null();'],
|
|---|
| 169 | [/Nan::Throw(\w*?)Error\((.+?)\);\n(\s*)return;/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n$3return env.Null();'],
|
|---|
| 170 | [/Nan::Throw(\w*?)Error\((.+?)\);/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n'],
|
|---|
| 171 | // Nan::RangeError(error) to Napi::RangeError::New(env, error)
|
|---|
| 172 | [/Nan::(\w*?)Error\((.+)\)/g, 'Napi::$1Error::New(env, $2)'],
|
|---|
| 173 |
|
|---|
| 174 | [/Nan::Set\((.+?),\n* *(.+?),\n* *(.+?),\n* *(.+?)\)/g, '$1.Set($2, $3, $4)'],
|
|---|
| 175 |
|
|---|
| 176 | [/Nan::(Escapable)?HandleScope\s+(\w+)\s*;/g, 'Napi::$1HandleScope $2(env);'],
|
|---|
| 177 | [/Nan::(Escapable)?HandleScope/g, 'Napi::$1HandleScope'],
|
|---|
| 178 | [/Nan::ForceSet\(([^,]+), ?/g, '$1->DefineProperty('],
|
|---|
| 179 | [/\.ForceSet\(Napi::String::New\(env, "(\w+)"\),\s*?/g, '.DefineProperty("$1", '],
|
|---|
| 180 | // [ /Nan::GetPropertyNames\(([^,]+)\)/, '$1->GetPropertyNames()' ],
|
|---|
| 181 | [/Nan::Equals\(([^,]+),/g, '$1.StrictEquals('],
|
|---|
| 182 |
|
|---|
| 183 | [/(.+)->Set\(/g, '$1.Set('],
|
|---|
| 184 |
|
|---|
| 185 | [/Nan::Callback/g, 'Napi::FunctionReference'],
|
|---|
| 186 |
|
|---|
| 187 | [/Nan::Persistent<Object>/g, 'Napi::ObjectReference'],
|
|---|
| 188 | [/Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target/g, 'Napi::Env& env, Napi::Object& target'],
|
|---|
| 189 |
|
|---|
| 190 | [/(\w+)\*\s+(\w+)\s*=\s*Nan::ObjectWrap::Unwrap<\w+>\(info\.This\(\)\);/g, '$1* $2 = this;'],
|
|---|
| 191 | [/Nan::ObjectWrap::Unwrap<(\w+)>\((.*)\);/g, '$2.Unwrap<$1>();'],
|
|---|
| 192 |
|
|---|
| 193 | [/Nan::NAN_METHOD_RETURN_TYPE/g, 'void'],
|
|---|
| 194 | [/NAN_INLINE/g, 'inline'],
|
|---|
| 195 |
|
|---|
| 196 | [/Nan::NAN_METHOD_ARGS_TYPE/g, 'const Napi::CallbackInfo&'],
|
|---|
| 197 | [/NAN_METHOD\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
|
|---|
| 198 | [/static\s*NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
|
|---|
| 199 | [/NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
|
|---|
| 200 | [/static\s*NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'],
|
|---|
| 201 | [/NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'],
|
|---|
| 202 | [/void Init\((v8::)*Local<(v8::)*Object> exports\)/g, 'Napi::Object Init(Napi::Env env, Napi::Object exports)'],
|
|---|
| 203 | [/NAN_MODULE_INIT\(([\w\d:]+?)\);/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports);'],
|
|---|
| 204 | [/NAN_MODULE_INIT\(([\w\d:]+?)\)/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports)'],
|
|---|
| 205 |
|
|---|
| 206 | [/::(Init(?:ialize)?)\(target\)/g, '::$1(env, target, module)'],
|
|---|
| 207 | [/constructor_template/g, 'constructor'],
|
|---|
| 208 |
|
|---|
| 209 | [/Nan::FunctionCallbackInfo<(v8::)?Value>[ ]*& [ ]*info\)[ ]*{\n*([ ]*)/gm, 'Napi::CallbackInfo& info) {\n$2Napi::Env env = info.Env();\n$2'],
|
|---|
| 210 | [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&\s*info\);/g, 'Napi::CallbackInfo& info);'],
|
|---|
| 211 | [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&/g, 'Napi::CallbackInfo&'],
|
|---|
| 212 |
|
|---|
| 213 | [/Buffer::HasInstance\(([^)]+)\)/g, '$1.IsBuffer()'],
|
|---|
| 214 |
|
|---|
| 215 | [/info\[(\d+)\]->/g, 'info[$1].'],
|
|---|
| 216 | [/info\[([\w\d]+)\]->/g, 'info[$1].'],
|
|---|
| 217 | [/info\.This\(\)->/g, 'info.This().'],
|
|---|
| 218 | [/->Is(Object|String|Int32|Number)\(\)/g, '.Is$1()'],
|
|---|
| 219 | [/info.GetReturnValue\(\).SetUndefined\(\)/g, 'return env.Undefined()'],
|
|---|
| 220 | [/info\.GetReturnValue\(\)\.Set\(((\n|.)+?)\);/g, 'return $1;'],
|
|---|
| 221 |
|
|---|
| 222 | // ex. Local<Value> to Napi::Value
|
|---|
| 223 | [/v8::Local<v8::(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'],
|
|---|
| 224 | [/Local<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'],
|
|---|
| 225 |
|
|---|
| 226 | // Declare an env in helper functions that take a Napi::Value
|
|---|
| 227 | [/(\w+)\(Napi::Value (\w+)(,\s*[^()]+)?\)\s*{\n*([ ]*)/gm, '$1(Napi::Value $2$3) {\n$4Napi::Env env = $2.Env();\n$4'],
|
|---|
| 228 |
|
|---|
| 229 | // delete #include <node.h> and/or <v8.h>
|
|---|
| 230 | [/#include +(<|")(?:node|nan).h("|>)/g, '#include $1napi.h$2\n#include $1uv.h$2'],
|
|---|
| 231 | // NODE_MODULE to NODE_API_MODULE
|
|---|
| 232 | [/NODE_MODULE/g, 'NODE_API_MODULE'],
|
|---|
| 233 | [/Nan::/g, 'Napi::'],
|
|---|
| 234 | [/nan.h/g, 'napi.h'],
|
|---|
| 235 |
|
|---|
| 236 | // delete .FromJust()
|
|---|
| 237 | [/\.FromJust\(\)/g, ''],
|
|---|
| 238 | // delete .ToLocalCheck()
|
|---|
| 239 | [/\.ToLocalChecked\(\)/g, ''],
|
|---|
| 240 | [/^.*->SetInternalFieldCount\(.*$/gm, ''],
|
|---|
| 241 |
|
|---|
| 242 | // replace using node; and/or using v8; to using Napi;
|
|---|
| 243 | [/using (node|v8);/g, 'using Napi;'],
|
|---|
| 244 | [/using namespace (node|Nan|v8);/g, 'using namespace Napi;'],
|
|---|
| 245 | // delete using v8::Local;
|
|---|
| 246 | [/using v8::Local;\n/g, ''],
|
|---|
| 247 | // replace using v8::XXX; with using Napi::XXX
|
|---|
| 248 | [/using v8::([A-Za-z]+);/g, 'using Napi::$1;']
|
|---|
| 249 |
|
|---|
| 250 | ];
|
|---|
| 251 |
|
|---|
| 252 | const paths = listFiles(dir);
|
|---|
| 253 | paths.forEach(function (dirEntry) {
|
|---|
| 254 | const filename = dirEntry.split('\\').pop().split('/').pop();
|
|---|
| 255 |
|
|---|
| 256 | // Check whether the file is a source file or a config file
|
|---|
| 257 | // then execute function accordingly
|
|---|
| 258 | const sourcePattern = /.+\.h|.+\.cc|.+\.cpp/;
|
|---|
| 259 | if (sourcePattern.test(filename)) {
|
|---|
| 260 | convertFile(dirEntry, SourceFileOperations);
|
|---|
| 261 | } else if (ConfigFileOperations[filename] != null) {
|
|---|
| 262 | convertFile(dirEntry, ConfigFileOperations[filename]);
|
|---|
| 263 | }
|
|---|
| 264 | });
|
|---|
| 265 |
|
|---|
| 266 | function listFiles (dir, filelist) {
|
|---|
| 267 | const files = fs.readdirSync(dir);
|
|---|
| 268 | filelist = filelist || [];
|
|---|
| 269 | files.forEach(function (file) {
|
|---|
| 270 | if (file === 'node_modules') {
|
|---|
| 271 | return;
|
|---|
| 272 | }
|
|---|
| 273 |
|
|---|
| 274 | if (fs.statSync(path.join(dir, file)).isDirectory()) {
|
|---|
| 275 | filelist = listFiles(path.join(dir, file), filelist);
|
|---|
| 276 | } else {
|
|---|
| 277 | filelist.push(path.join(dir, file));
|
|---|
| 278 | }
|
|---|
| 279 | });
|
|---|
| 280 | return filelist;
|
|---|
| 281 | }
|
|---|
| 282 |
|
|---|
| 283 | function convert (content, operations) {
|
|---|
| 284 | for (let i = 0; i < operations.length; i++) {
|
|---|
| 285 | const operation = operations[i];
|
|---|
| 286 | content = content.replace(operation[0], operation[1]);
|
|---|
| 287 | }
|
|---|
| 288 | return content;
|
|---|
| 289 | }
|
|---|
| 290 |
|
|---|
| 291 | function convertFile (fileName, operations) {
|
|---|
| 292 | fs.readFile(fileName, 'utf-8', function (err, file) {
|
|---|
| 293 | if (err) throw err;
|
|---|
| 294 |
|
|---|
| 295 | file = convert(file, operations);
|
|---|
| 296 |
|
|---|
| 297 | fs.writeFile(fileName, file, function (err) {
|
|---|
| 298 | if (err) throw err;
|
|---|
| 299 | });
|
|---|
| 300 | });
|
|---|
| 301 | }
|
|---|
