Lint node_script.cc

2 files changed, 187 insertions, 138 deletions

diff --git a/src/node_script.cc b/src/node_script.cc
index 5c4223d10e4..81d10958184 100644
--- a/src/node_script.cc
+++ b/src/node_script.cc
@@ -2,109 +2,198 @@
 #include <node_script.h>
 #include <assert.h>
 
+namespace node {
 
+using v8::Context;
+using v8::Script;
+using v8::Value;
+using v8::Handle;
+using v8::HandleScope;
+using v8::Object;
+using v8::Arguments;
+using v8::ThrowException;
+using v8::TryCatch;
+using v8::String;
+using v8::Exception;
+using v8::Local;
+using v8::Array;
+using v8::Persistent;
+using v8::Integer;
+using v8::FunctionTemplate;
 
-using namespace v8;
-using namespace node;
 
+class WrappedContext : ObjectWrap {
+ public:
+  static void Initialize(Handle<Object> target);
+  static Handle<Value> New(const Arguments& args);
 
-Persistent<FunctionTemplate> node::Context::constructor_template;
+  Persistent<Context> GetV8Context();
+  static Local<Object> NewInstance();
 
+ protected:
 
-void node::Context::Initialize (Handle<Object> target) {
+  static Persistent<FunctionTemplate> constructor_template;
+
+  WrappedContext();
+  ~WrappedContext();
+
+  Persistent<Context> context_;
+};
+
+
+Persistent<FunctionTemplate> WrappedContext::constructor_template;
+
+
+class WrappedScript : ObjectWrap {
+ public:
+  static void Initialize(Handle<Object> target);
+
+  enum EvalInputFlags { compileCode, unwrapExternal };
+  enum EvalContextFlags { thisContext, newContext, userContext };
+  enum EvalOutputFlags { returnResult, wrapExternal };
+
+  template <EvalInputFlags input_flag,
+            EvalContextFlags context_flag,
+            EvalOutputFlags output_flag>
+  static Handle<Value> EvalMachine(const Arguments& args);
+
+ protected:
+  static Persistent<FunctionTemplate> constructor_template;
+
+  WrappedScript() : ObjectWrap() {}
+  ~WrappedScript();
+
+  static Handle<Value> New(const Arguments& args);
+  static Handle<Value> CreateContext(const Arguments& arg);
+  static Handle<Value> RunInContext(const Arguments& args);
+  static Handle<Value> RunInThisContext(const Arguments& args);
+  static Handle<Value> RunInNewContext(const Arguments& args);
+  static Handle<Value> CompileRunInContext(const Arguments& args);
+  static Handle<Value> CompileRunInThisContext(const Arguments& args);
+  static Handle<Value> CompileRunInNewContext(const Arguments& args);
+
+  Persistent<Script> script_;
+};
+
+
+void WrappedContext::Initialize(Handle<Object> target) {
   HandleScope scope;
 
-  Local<FunctionTemplate> t = FunctionTemplate::New(node::Context::New);
+  Local<FunctionTemplate> t = FunctionTemplate::New(WrappedContext::New);
   constructor_template = Persistent<FunctionTemplate>::New(t);
   constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
   constructor_template->SetClassName(String::NewSymbol("Context"));
 
-  target->Set(String::NewSymbol("Context"), constructor_template->GetFunction());
+  target->Set(String::NewSymbol("Context"),
+              constructor_template->GetFunction());
 }
 
 
-Handle<Value> node::Context::New (const Arguments& args) {
+Handle<Value> WrappedContext::New(const Arguments& args) {
   HandleScope scope;
 
-  node::Context *t = new node::Context();
+  WrappedContext *t = new WrappedContext();
   t->Wrap(args.This());
 
   return args.This();
 }
 
 
-node::Context::Context() : ObjectWrap() {
-  context_ = v8::Context::New();
+WrappedContext::WrappedContext() : ObjectWrap() {
+  context_ = Context::New();
 }
 
 
-node::Context::~Context() {
+WrappedContext::~WrappedContext() {
   context_.Dispose();
 }
 
 
-Local<Object> node::Context::NewInstance() {
+Local<Object> WrappedContext::NewInstance() {
   Local<Object> context = constructor_template->GetFunction()->NewInstance();
   return context;
 }
 
 
-v8::Persistent<v8::Context> node::Context::GetV8Context() {
-	return context_;
+Persistent<Context> WrappedContext::GetV8Context() {
+  return context_;
 }
 
 
-Persistent<FunctionTemplate> node::Script::constructor_template;
+Persistent<FunctionTemplate> WrappedScript::constructor_template;
 
 
-void node::Script::Initialize (Handle<Object> target) {
+void WrappedScript::Initialize(Handle<Object> target) {
   HandleScope scope;
 
-  Local<FunctionTemplate> t = FunctionTemplate::New(node::Script::New);
+  Local<FunctionTemplate> t = FunctionTemplate::New(WrappedScript::New);
   constructor_template = Persistent<FunctionTemplate>::New(t);
   constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
   constructor_template->SetClassName(String::NewSymbol("Script"));
 
-  NODE_SET_PROTOTYPE_METHOD(constructor_template, "createContext", node::Script::CreateContext);
-  NODE_SET_PROTOTYPE_METHOD(constructor_template, "runInContext", node::Script::RunInContext);
-  NODE_SET_PROTOTYPE_METHOD(constructor_template, "runInThisContext", node::Script::RunInThisContext);
-  NODE_SET_PROTOTYPE_METHOD(constructor_template, "runInNewContext", node::Script::RunInNewContext);
-  NODE_SET_METHOD(constructor_template, "createContext", node::Script::CreateContext);
-  NODE_SET_METHOD(constructor_template, "runInContext", node::Script::CompileRunInContext);
-  NODE_SET_METHOD(constructor_template, "runInThisContext", node::Script::CompileRunInThisContext);
-  NODE_SET_METHOD(constructor_template, "runInNewContext", node::Script::CompileRunInNewContext);
+  NODE_SET_PROTOTYPE_METHOD(constructor_template,
+                            "createContext",
+                            WrappedScript::CreateContext);
 
-  target->Set(String::NewSymbol("Script"), constructor_template->GetFunction());
+  NODE_SET_PROTOTYPE_METHOD(constructor_template,
+                            "runInContext",
+                            WrappedScript::RunInContext);
+
+  NODE_SET_PROTOTYPE_METHOD(constructor_template,
+                            "runInThisContext",
+                            WrappedScript::RunInThisContext);
+
+  NODE_SET_PROTOTYPE_METHOD(constructor_template,
+                            "runInNewContext",
+                            WrappedScript::RunInNewContext);
+
+  NODE_SET_METHOD(constructor_template,
+                  "createContext",
+                  WrappedScript::CreateContext);
+
+  NODE_SET_METHOD(constructor_template,
+                  "runInContext",
+                  WrappedScript::CompileRunInContext);
+
+  NODE_SET_METHOD(constructor_template,
+                  "runInThisContext",
+                  WrappedScript::CompileRunInThisContext);
+
+  NODE_SET_METHOD(constructor_template,
+                  "runInNewContext",
+                  WrappedScript::CompileRunInNewContext);
+
+  target->Set(String::NewSymbol("Script"),
+              constructor_template->GetFunction());
 }
 
 
-Handle<Value> node::Script::New (const Arguments& args) {
+Handle<Value> WrappedScript::New(const Arguments& args) {
   if (!args.IsConstructCall()) {
     return FromConstructorTemplate(constructor_template, args);
   }
 
   HandleScope scope;
 
-  node::Script *t = new node::Script();
+  WrappedScript *t = new WrappedScript();
   t->Wrap(args.Holder());
 
   return
-    node::Script::EvalMachine<compileCode, thisContext, wrapExternal>(args);
+    WrappedScript::EvalMachine<compileCode, thisContext, wrapExternal>(args);
 }
 
 
-node::Script::~Script() {
+WrappedScript::~WrappedScript() {
   script_.Dispose();
 }
 
 
-Handle<Value> node::Script::CreateContext (const Arguments& args) {
+Handle<Value> WrappedScript::CreateContext(const Arguments& args) {
   HandleScope scope;
 
-  Local<v8::Object> context = node::Context::NewInstance();
+  Local<Object> context = WrappedContext::NewInstance();
 
   if (args.Length() > 0) {
-
     Local<Object> sandbox = args[0]->ToObject();
     Local<Array> keys = sandbox->GetPropertyNames();
 
@@ -120,93 +209,94 @@ Handle<Value> node::Script::CreateContext (const Arguments& args) {
 }
 
 
-Handle<Value> node::Script::RunInContext (const Arguments& args) {
+Handle<Value> WrappedScript::RunInContext(const Arguments& args) {
   return
-    node::Script::EvalMachine<unwrapExternal, userContext, returnResult>(args);
+    WrappedScript::EvalMachine<unwrapExternal, userContext, returnResult>(args);
 }
 
 
-Handle<Value> node::Script::RunInThisContext (const Arguments& args) {
+Handle<Value> WrappedScript::RunInThisContext(const Arguments& args) {
   return
-    node::Script::EvalMachine<unwrapExternal, thisContext, returnResult>(args);
+    WrappedScript::EvalMachine<unwrapExternal, thisContext, returnResult>(args);
 }
 
 
-Handle<Value> node::Script::RunInNewContext(const Arguments& args) {
+Handle<Value> WrappedScript::RunInNewContext(const Arguments& args) {
   return
-    node::Script::EvalMachine<unwrapExternal, newContext, returnResult>(args);
+    WrappedScript::EvalMachine<unwrapExternal, newContext, returnResult>(args);
 }
 
 
-Handle<Value> node::Script::CompileRunInContext (const Arguments& args) {
+Handle<Value> WrappedScript::CompileRunInContext(const Arguments& args) {
   return
-    node::Script::EvalMachine<compileCode, userContext, returnResult>(args);
+    WrappedScript::EvalMachine<compileCode, userContext, returnResult>(args);
 }
 
 
-Handle<Value> node::Script::CompileRunInThisContext (const Arguments& args) {
+Handle<Value> WrappedScript::CompileRunInThisContext(const Arguments& args) {
   return
-    node::Script::EvalMachine<compileCode, thisContext, returnResult>(args);
+    WrappedScript::EvalMachine<compileCode, thisContext, returnResult>(args);
 }
 
 
-Handle<Value> node::Script::CompileRunInNewContext(const Arguments& args) {
+Handle<Value> WrappedScript::CompileRunInNewContext(const Arguments& args) {
   return
-    node::Script::EvalMachine<compileCode, newContext, returnResult>(args);
+    WrappedScript::EvalMachine<compileCode, newContext, returnResult>(args);
 }
 
 
-template <node::Script::EvalInputFlags iFlag,
-          node::Script::EvalContextFlags cFlag,
-          node::Script::EvalOutputFlags oFlag>
-    Handle<Value> node::Script::EvalMachine(const Arguments& args) {
-
+template <WrappedScript::EvalInputFlags input_flag,
+          WrappedScript::EvalContextFlags context_flag,
+          WrappedScript::EvalOutputFlags output_flag>
+Handle<Value> WrappedScript::EvalMachine(const Arguments& args) {
   HandleScope scope;
 
-  if (iFlag == compileCode && args.Length() < 1) {
+  if (input_flag == compileCode && args.Length() < 1) {
     return ThrowException(Exception::TypeError(
           String::New("needs at least 'code' argument.")));
   }
 
-  const int sbIndex = iFlag == compileCode ? 1 : 0;
-  if (cFlag == userContext && args.Length() < (sbIndex + 1)) {
+  const int sandbox_index = input_flag == compileCode ? 1 : 0;
+  if (context_flag == userContext && args.Length() < (sandbox_index + 1)) {
     return ThrowException(Exception::TypeError(
           String::New("needs a 'context' argument.")));
   }
 
 
   Local<String> code;
-  if (iFlag == compileCode) code = args[0]->ToString();
+  if (input_flag == compileCode) code = args[0]->ToString();
 
   Local<Object> sandbox;
-  if (cFlag == newContext) {
-    sandbox = args[sbIndex]->IsObject() ? args[sbIndex]->ToObject() : Object::New();
-  } else if (cFlag == userContext) {
-    sandbox = args[sbIndex]->ToObject();
+  if (context_flag == newContext) {
+    sandbox = args[sandbox_index]->IsObject() ? args[sandbox_index]->ToObject()
+                                              : Object::New();
+  } else if (context_flag == userContext) {
+    sandbox = args[sandbox_index]->ToObject();
   }
 
-  const int fnIndex = sbIndex + (cFlag == newContext ? 1 : 0);
-  Local<String> filename = args.Length() > fnIndex
-                           ? args[fnIndex]->ToString()
+  const int filename_index = sandbox_index +
+                             (context_flag == newContext ? 1 : 0);
+  Local<String> filename = args.Length() > filename_index
+                           ? args[filename_index]->ToString()
                            : String::New("evalmachine.<anonymous>");
 
-  Persistent<v8::Context> context;
+  Persistent<Context> context;
 
   Local<Array> keys;
   unsigned int i;
-  if (cFlag == newContext) {
+  if (context_flag == newContext) {
     // Create the new context
-    context = v8::Context::New();
+    context = Context::New();
 
-  } else if (cFlag == userContext) {
+  } else if (context_flag == userContext) {
     // Use the passed in context
-    Local<Object> contextArg = args[sbIndex]->ToObject();
-    node::Context *nContext = ObjectWrap::Unwrap<node::Context>(sandbox);
+    Local<Object> contextArg = args[sandbox_index]->ToObject();
+    WrappedContext *nContext = ObjectWrap::Unwrap<WrappedContext>(sandbox);
     context = nContext->GetV8Context();
   }
 
   // New and user context share code. DRY it up.
-  if (cFlag == userContext || cFlag == newContext) {
+  if (context_flag == userContext || context_flag == newContext) {
     // Enter the context
     context->Enter();
 
@@ -226,13 +316,13 @@ template <node::Script::EvalInputFlags iFlag,
   TryCatch try_catch;
 
   Handle<Value> result;
-  Handle<v8::Script> script;
+  Handle<Script> script;
 
-  if (iFlag == compileCode) {
-    // well, here node::Script::New would suffice in all cases, but maybe
+  if (input_flag == compileCode) {
+    // well, here WrappedScript::New would suffice in all cases, but maybe
     // Compile has a little better performance where possible
-    script = oFlag == returnResult ? v8::Script::Compile(code, filename)
-                                   : v8::Script::New(code, filename);
+    script = output_flag == returnResult ? Script::Compile(code, filename)
+                                         : Script::New(code, filename);
     if (script.IsEmpty()) {
       // FIXME UGLY HACK TO DISPLAY SYNTAX ERRORS.
       DisplayExceptionLine(try_catch);
@@ -241,33 +331,34 @@ template <node::Script::EvalInputFlags iFlag,
       return try_catch.ReThrow();
     }
   } else {
-    node::Script *nScript = ObjectWrap::Unwrap<node::Script>(args.Holder());
-    if (!nScript) {
+    WrappedScript *n_script = ObjectWrap::Unwrap<WrappedScript>(args.Holder());
+    if (!n_script) {
       return ThrowException(Exception::Error(
-            String::New("Must be called as a method of Script.")));
-    } else if (nScript->script_.IsEmpty()) {
+            String::New("Must be called as a method of WrappedScript.")));
+    } else if (n_script->script_.IsEmpty()) {
       return ThrowException(Exception::Error(
-            String::New("'this' must be a result of previous new Script(code) call.")));
+            String::New("'this' must be a result of previous "
+                        "new WrappedScript(code) call.")));
     }
 
-    script = nScript->script_;
+    script = n_script->script_;
   }
 
 
-  if (oFlag == returnResult) {
+  if (output_flag == returnResult) {
     result = script->Run();
     if (result.IsEmpty()) return try_catch.ReThrow();
   } else {
-    node::Script *nScript = ObjectWrap::Unwrap<node::Script>(args.Holder());
-    if (!nScript) {
+    WrappedScript *n_script = ObjectWrap::Unwrap<WrappedScript>(args.Holder());
+    if (!n_script) {
       return ThrowException(Exception::Error(
-            String::New("Must be called as a method of Script.")));
+            String::New("Must be called as a method of WrappedScript.")));
     }
-    nScript->script_ = Persistent<v8::Script>::New(script);
+    n_script->script_ = Persistent<Script>::New(script);
     result = args.This();
   }
 
-  if (cFlag == userContext || cFlag == newContext) {
+  if (context_flag == userContext || context_flag == newContext) {
     // success! copy changes back onto the sandbox object.
     keys = context->Global()->GetPropertyNames();
     for (i = 0; i < keys->Length(); i++) {
@@ -278,12 +369,12 @@ template <node::Script::EvalInputFlags iFlag,
     }
   }
 
-  if (cFlag == newContext) {
+  if (context_flag == newContext) {
     // Clean up, clean up, everybody everywhere!
     context->DetachGlobal();
     context->Exit();
     context.Dispose();
-  } else if (cFlag == userContext) {
+  } else if (context_flag == userContext) {
     // Exit the passed in context.
     context->Exit();
   }
@@ -291,11 +382,17 @@ template <node::Script::EvalInputFlags iFlag,
   return result == args.This() ? result : scope.Close(result);
 }
 
-void node::InitEvals(Handle<Object> target) {
+
+void InitEvals(Handle<Object> target) {
   HandleScope scope;
 
-  node::Context::Initialize(target);
-  node::Script::Initialize(target);
+  WrappedContext::Initialize(target);
+  WrappedScript::Initialize(target);
 }
 
+
+}  // namespace node
+
+
 NODE_MODULE(node_evals, node::InitEvals);
+
diff --git a/src/node_script.h b/src/node_script.h
index bd300459f51..364bd18ca8a 100644
--- a/src/node_script.h
+++ b/src/node_script.h
@@ -8,54 +8,6 @@
 
 namespace node {
 
-class Context : ObjectWrap {
- public:
-  static void Initialize (v8::Handle<v8::Object> target);
-  static v8::Handle<v8::Value> New (const v8::Arguments& args);
-
-  v8::Persistent<v8::Context> GetV8Context();
-  static v8::Local<v8::Object> NewInstance();
-
- protected:
-
-  static v8::Persistent<v8::FunctionTemplate> constructor_template;
-
-  Context ();
-  ~Context();
-
-  v8::Persistent<v8::Context> context_;
-};
-
-
-class Script : ObjectWrap {
- public:
-  static void Initialize (v8::Handle<v8::Object> target);
-
-  enum EvalInputFlags { compileCode, unwrapExternal };
-  enum EvalContextFlags { thisContext, newContext, userContext };
-  enum EvalOutputFlags { returnResult, wrapExternal };
-
-  template <EvalInputFlags iFlag, EvalContextFlags cFlag, EvalOutputFlags oFlag>
-  static v8::Handle<v8::Value> EvalMachine(const v8::Arguments& args);
-
- protected:
-  static v8::Persistent<v8::FunctionTemplate> constructor_template;
-
-  Script () : ObjectWrap () {}
-  ~Script();
-
-  static v8::Handle<v8::Value> New (const v8::Arguments& args);
-  static v8::Handle<v8::Value> CreateContext (const v8::Arguments& arg);
-  static v8::Handle<v8::Value> RunInContext (const v8::Arguments& args);
-  static v8::Handle<v8::Value> RunInThisContext (const v8::Arguments& args);
-  static v8::Handle<v8::Value> RunInNewContext (const v8::Arguments& args);
-  static v8::Handle<v8::Value> CompileRunInContext (const v8::Arguments& args);
-  static v8::Handle<v8::Value> CompileRunInThisContext (const v8::Arguments& args);
-  static v8::Handle<v8::Value> CompileRunInNewContext (const v8::Arguments& args);
-
-  v8::Persistent<v8::Script> script_;
-};
-
 
 void InitEvals(v8::Handle<v8::Object> target);