implemening and testing FlagList functions

Author: thlorenz

Diff for: binding.gyp

@@ -1,5 +1,16 @@
 {
   'targets': [
+    {
+      'target_name': 'v8_flag_list',
+      'sources': [
+         'src/v8_flag_list.cc'
+      ],
+      'include_dirs': [
+        '<!(node -e "require(\'nan\')")',
+        '<!(node -e \'console.log(require("path").join(process.env.HOME, ".node-gyp", process.versions.node, "src"))\')',
+        '<!(node -e \'console.log(require("path").join(process.env.HOME, ".node-gyp", process.versions.node, "deps", "v8", "src"))\')'
+      ]
+    },
     {
       'target_name': 'v8_flags',
       'sources': [

Diff for: index.js

@@ -1,7 +1,8 @@
 'use strict';
 
 var v8_flags = require('./build/Release/v8_flags')
-  , v8_meta  = require('./build/Release/v8_flags_meta');
+  , v8_meta  = require('./build/Release/v8_flags_meta')
+  , v8_flag_list = require('./build/Release/v8_flag_list')
 
 // The following flags aren't configurable after startup since they activate (or don't) during the bootstrapping process
 // https://github.com/v8/v8/blob/146bf7bec2518cf664994a658dfc4a72a9c6bb10/src/bootstrapper.cc#L86-L97
@@ -17,9 +18,41 @@ var notConfigurable = [
   , 'harmony_collections'
 ]
 
+/**
+ * Exposes methods to get and set v8 flags.
+ *
+ * #### Example
+ *
+ * ```js
+ * var flags = require('v8-flags').flags;
+ * console.log(flags.use_strict()); // false
+ * flags.use_strict(true)
+ * console.log(flags.use_strict()); // true
+ * ```
+ * 
+ * @name flags
+ * @function
+ */
 var flags = exports.flags = v8_flags;
 
-// constant meta data is initialized on startup from the definitions found in C++ land
+//
+/**
+ * The meta data for the flags.
+ *
+ * It is initialized on startup from the definitions found in C++ land.
+ * 
+ * @name meta
+ * @function
+ * @return {Array.<Object>} array of objects with the folloing properties each
+ *  - **name:** flag name
+ *  - **default:** default setting of the flag
+ *  - **type:** type of the flag
+ *  - **description:** the description of the flag
+ *  - **readonly:** set `true` if flag cannot be set
+ *  - **configurable:** set `true` if setting the flag at runtime has the desired effect
+ *  - **implications:** flags that will be set to `true` whenever this flag is `true` and `enforceFlagImplications` is called
+ *  - **negativeImplications:** flags that will be set to `false` whenever this flag is `false` and `enforceFlagImplications` is called
+ */
 exports.meta = Object.keys(v8_meta)
   .filter(function (k) { 
     return k.slice(0, 13) !== 'implications_' 
@@ -48,11 +81,42 @@ exports.meta = Object.keys(v8_meta)
     return acc;
   }, {});
 
+/**
+ * Lists all flags along with their **current** value.
+ * 
+ * @name listFlags
+ * @function
+ * @return {Object} key/value pair for each flag
+ */
 exports.listFlags  = function () {
   return Object.keys(flags)
-    .filter(function (k) { return k.slice(0, 4) !== 'set_' })
     .reduce(function (acc, k) {
       acc[k] = flags[k]();
       return acc;
     }, {})
 }
+
+/**
+ * Prints flag help to the console.
+ * 
+ * @name printHelp
+ * @function
+ */
+exports.printHelp = v8_flag_list.printHelp;
+
+/**
+ * Resets all flags to their default values
+ * 
+ * @name resetAllFlags 
+ * @function
+ */
+exports.resetAllFlags = v8_flag_list.resetAllFlags;
+
+
+/**
+ * Enforces all flag implications.
+ * 
+ * @name enforceFlagImplications
+ * @function
+ */
+exports.enforceFlagImplications = v8_flag_list.enforceFlagImplications;

Diff for: src/v8_flag_list.cc

@@ -0,0 +1,34 @@
+#include <nan.h>
+#include "v8.h"
+
+#include "atomicops.h"
+#include "flags.h"
+#include <node.h>
+
+namespace i = v8::internal;
+
+// Reset all flags to their default value.
+NAN_METHOD(ResetAllFlags) {
+  i::FlagList::ResetAllFlags();
+  NanReturnUndefined();
+}
+
+// Print help to stdout with flags, types, and default values.
+NAN_METHOD(PrintHelp) {
+  i::FlagList::PrintHelp();
+  NanReturnUndefined();
+}
+
+// Set flags as consequence of being implied by another flag.
+NAN_METHOD(EnforceFlagImplications) {
+  i::FlagList::EnforceFlagImplications();
+  NanReturnUndefined();
+}
+
+void init(v8::Handle<v8::Object> exports) {
+  exports->Set(NanNew<v8::String>("resetAllFlags"), NanNew<v8::FunctionTemplate>(ResetAllFlags)->GetFunction());
+  exports->Set(NanNew<v8::String>("printHelp"), NanNew<v8::FunctionTemplate>(PrintHelp)->GetFunction());
+  exports->Set(NanNew<v8::String>("enforceFlagImplications"), NanNew<v8::FunctionTemplate>(EnforceFlagImplications)->GetFunction());
+}
+
+NODE_MODULE(v8_flag_list, init)

Diff for: test.sh

@@ -9,13 +9,13 @@ fi
 
 export PATH=$DIR/node_modules/.bin:$PATH
 
-set -e
+set -e;
 
 if [[ -e $TRAVIS ]]
 then
   npm install
   tap $DIR/test/*.js
 else
   nave use $1 npm install
-  nave use $1 node $DIR/test/index.js
+  for t in $DIR/test/*.js; do nave use $1 node $t; done
 fi

Diff for: test/implications.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var test = require('tap').test
+var v8Flags = require('../')
+  , flags = v8Flags.flags
+  , enforceImplications = v8Flags.enforceFlagImplications
+
+
+test('\nwhen setting harmony all implied harmony flags get set ONLY after enforcing flag implications, and never when unsetting', function (t) {
+  t.on('end', function () {
+    flags.harmony(false)    
+    flags.harmony_scoping(false)
+    flags.harmony_modules(false)
+    flags.harmony_proxies(false)
+    flags.harmony_collections(false)
+  })
+
+  flags.harmony(true)    
+  t.ok(!flags.harmony_scoping(), 'harmony_scoping off')
+  t.ok(!flags.harmony_modules(), 'harmony_modules off')
+  t.ok(!flags.harmony_proxies(), 'harmony_proxies off')
+  t.ok(!flags.harmony_collections(), 'harmony_collections off')
+
+  enforceImplications()
+
+  t.ok(flags.harmony_scoping(), 'harmony_scoping on after enforcement')
+  t.ok(flags.harmony_modules(), 'harmony_modules on after enforcement')
+  t.ok(flags.harmony_proxies(), 'harmony_proxies on after enforcement')
+  t.ok(flags.harmony_collections(), 'harmony_collections on after enforcement')
+
+  flags.harmony(false)    
+  enforceImplications()
+
+  t.ok(flags.harmony_scoping(), 'harmony_scoping still on')
+  t.ok(flags.harmony_modules(), 'harmony_modules still on')
+  t.ok(flags.harmony_proxies(), 'harmony_proxies still on')
+  t.ok(flags.harmony_collections(), 'harmony_collections still on')
+
+  t.end()
+})

Diff for: test/reset-all-flags.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var test = require('tap').test
+var v8Flags = require('../')
+  , flags = v8Flags.flags
+  , resetAllFlags= v8Flags.resetAllFlags
+
+test('\nresetting all flags resets only `false` by default flags to `false`', function (t) {
+  t.on('end', resetAllFlags)   
+
+  flags.use_strict(true)
+  flags.trap_on_deopt(true)
+
+  t.ok(flags.use_strict(), 'use_strict on')
+  t.ok(flags.trap_on_deopt(), 'trap_on_deopt on')
+  t.ok(flags.crankshaft(), 'crankshaft on by default')
+
+  resetAllFlags()
+
+  t.ok(!flags.use_strict(), 'use_strict off')
+  t.ok(!flags.trap_on_deopt(), 'trap_on_deopt off')
+  t.ok(flags.crankshaft(), 'crankshaft on by default')
+
+  t.end()
+})