json5 0.0.1

data/lib/json5/stringifier.rb

@@ -0,0 +1,242 @@
+module JSON5
+  class Stringifier
+# # JSON5 stringify will not quote keys where appropriate
+# JSON5.stringify = function (obj, replacer, space)
+    def initialize obj, replacer, space
+      if (replacer && (typeof(replacer) != "function" && !isArray(replacer)))
+        throw new Error('Replacer must be a function or an array')
+      end
+    end
+
+    def getReplacedValueOrUndefined holder, key, isTopLevel
+      value = holder[key]
+
+      # Replace the value with its toJSON value first, if possible
+      # if (value && value.toJSON && typeof value.toJSON === "function")
+      if (value && value.responds_to?(:to_json))
+          # value = value.toJSON
+          value = value.to_json
+      end
+
+      # If the user-supplied replacer if a function, call it. If it's an array, check objects' string keys for
+      # presence in the array (removing the key/value pair from the resulting JSON if the key is missing).
+      if (typeof(replacer) === "function")
+          return replacer.call(holder, key, value)
+      elsif(replacer)
+          if (isTopLevel || isArray(holder) || replacer.indexOf(key) >= 0)
+              return value
+          else
+              return undefined
+          end
+      else
+          return value
+      end
+    end
+
+    def isWordChar(char)
+      return (char >= 'a' && char <= 'z') ||
+          (char >= 'A' && char <= 'Z') ||
+          (char >= '0' && char <= '9') ||
+          char === '_' || char === '$'
+    end
+
+    def isWordStart(char)
+      return (char >= 'a' && char <= 'z') ||
+          (char >= 'A' && char <= 'Z') ||
+          char === '_' || char === '$'
+    end
+
+    def isWord(key)
+      if (typeof key != 'string')
+          return false
+      end
+      if (!isWordStart(key[0]))
+          return false
+      end
+      i = 1, length = key.length
+      while (i < length) do
+          if (!isWordChar(key[i]))
+              return false
+          end
+          i += 1
+      end
+      return true
+    end
+
+  #     # export for use in tests
+  #     JSON5.isWord = isWord
+
+  #     # polyfills
+    def isArray(obj)
+      if (Array.isArray)
+          return Array.isArray(obj)
+      else
+          return Object.prototype.toString.call(obj) === '[object Array]'
+      end
+    end
+
+    def isDate(obj)
+      return Object.prototype.toString.call(obj) === '[object Date]'
+    end
+
+    # isNaN = isNaN || ->(val)
+    #   return typeof val === 'number' && val != val
+    # end
+
+  #     objStack = []
+  #     def checkForCircular(obj)
+  #         for (i = 0; i < objStack.length; i++)
+  #             if (objStack[i] === obj)
+  #                 throw new TypeError("Converting circular structure to JSON")
+  #             end
+  #         end
+  #     end
+
+  #     def makeIndent(str, num, noNewLine)
+  #         if (!str)
+  #             return ""
+  #         end
+  #         # indentation no more than 10 chars
+  #         if (str.length > 10)
+  #             str = str.substring(0, 10)
+  #         end
+
+  #         indent = noNewLine ? "" : "\n"
+  #         for (i = 0; i < num; i++)
+  #             indent += str
+  #         end
+
+  #         return indent
+  #     end
+
+  #     indentStr
+  #     if (space)
+  #         if (typeof space === "string")
+  #             indentStr = space
+  #         elsif (typeof space === "number" && space >= 0)
+  #             indentStr = makeIndent(" ", space, true)
+  #         else
+  #             # ignore space parameter
+  #         end
+  #     end
+
+  #     # Copied from Crokford's implementation of JSON
+  #     # See https://github.com/douglascrockford/JSON-js/blob/e39db4b7e6249f04a195e7dd0840e610cc9e941e/json2.js#L195
+  #     # Begin
+  #     cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+  #         escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+  #         meta = { # table of character substitutions
+  #         '\b': '\\b',
+  #         '\t': '\\t',
+  #         '\n': '\\n',
+  #         '\f': '\\f',
+  #         '\r': '\\r',
+  #         '"' : '\\"',
+  #         '\\': '\\\\'
+  #     end
+  #     def escapeString(string)
+
+  # # If the string contains no control characters, no quote characters, and no
+  # # backslash characters, then we can safely slap some quotes around it.
+  # # Otherwise we must also replace the offending characters with safe escape
+  # # sequences.
+  #         escapable.lastIndex = 0
+  #         return escapable.test(string) ? '"' + string.replace(escapable, function (a)
+  #             c = meta[a]
+  #             return typeof c === 'string' ?
+  #                 c :
+  #                 '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4)
+  #         end) + '"' : '"' + string + '"'
+  #     end
+  #     # End
+
+  #     def internalStringify(holder, key, isTopLevel)
+  #         buffer, res
+
+  #         # Replace the value, if necessary
+  #         obj_part = getReplacedValueOrUndefined(holder, key, isTopLevel)
+
+  #         if (obj_part && !isDate(obj_part))
+  #             # unbox objects
+  #             # don't unbox dates, since will turn it into number
+  #             obj_part = obj_part.valueOf
+  #         end
+  #         switch(typeof obj_part)
+  #             when "boolean"
+  #                 return obj_part.toString
+
+  #             when "number"
+  #                 if (isNaN(obj_part) || !isFinite(obj_part))
+  #                     return "null"
+  #                 end
+  #                 return obj_part.toString
+
+  #             when "string"
+  #                 return escapeString(obj_part.toString)
+
+  #             when "object"
+  #                 if (obj_part === null)
+  #                     return "null"
+  #                 elsif (isArray(obj_part))
+  #                     checkForCircular(obj_part)
+  #                     buffer = "["
+  #                     objStack.push(obj_part)
+
+  #                     for (i = 0; i < obj_part.length; i++)
+  #                         res = internalStringify(obj_part, i, false)
+  #                         buffer += makeIndent(indentStr, objStack.length)
+  #                         if (res === null || typeof res === "undefined")
+  #                             buffer += "null"
+  #                         else
+  #                             buffer += res
+  #                         end
+  #                         if (i < obj_part.length-1)
+  #                             buffer += ","
+  #                         elsif (indentStr)
+  #                             buffer += "\n"
+  #                         end
+  #                     end
+  #                     objStack.pop
+  #                     buffer += makeIndent(indentStr, objStack.length, true) + "]"
+  #                 else
+  #                     checkForCircular(obj_part)
+  #                     buffer = "{"
+  #                     nonEmpty = false
+  #                     objStack.push(obj_part)
+  #                     for (prop in obj_part)
+  #                         if (obj_part.hasOwnProperty(prop))
+  #                             value = internalStringify(obj_part, prop, false)
+  #                             isTopLevel = false
+  #                             if (typeof value != "undefined" && value != null)
+  #                                 buffer += makeIndent(indentStr, objStack.length)
+  #                                 nonEmpty = true
+  #                                 key = isWord(prop) ? prop : escapeString(prop)
+  #                                 buffer += key + ":" + (indentStr ? ' ' : '') + value + ","
+  #                             end
+  #                         end
+  #                     end
+  #                     objStack.pop
+  #                     if (nonEmpty)
+  #                         buffer = buffer.substring(0, buffer.length-1) + makeIndent(indentStr, objStack.length) + "}"
+  #                     else
+  #                         buffer = '{}'
+  #                     end
+  #                 end
+  #                 return buffer
+  #             else
+  #                 # functions and undefined should be ignored
+  #                 return undefined
+  #         end
+  #     end
+
+  #     # special case...when undefined is used inside of
+  #     # a compound object/array, return null.
+  #     # but when top-level, return undefined
+  #     topLevelHolder = {"":obj}
+  #     if (obj === undefined)
+  #         return getReplacedValueOrUndefined(topLevelHolder, '', true)
+  #     end
+  #     return internalStringify(topLevelHolder, '', true)
+  # end
+  end
+end

data/lib/json5/version.rb

@@ -0,0 +1,3 @@
+module JSON5
+  VERSION = "0.0.1"
+end

data/spec/json5/parse_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe JSON5 do
+  def parseJSON5
+    JSON5.parse(@str)
+  end
+
+  def parseJSON
+    Oj.load(@str)
+  end
+
+  def parseES5
+    js = V8::Context.new.eval("\"use strict\"; (\n" + @str + "\n)")
+    unify(js)
+  end
+
+  def unify obj
+    case obj
+    when V8::Array
+      unify(obj.to_a)
+    when V8::Object
+      unify(obj.to_h)
+    when Hash
+      obj.map{ |k, v| [k, unify(v)] }.to_h
+    when Array
+      obj.map{ |v| unify(v) }
+    else
+      obj
+    end
+  end
+
+  Dir[File.expand_path('../../parse-cases/**/*.*', __FILE__)].each do |path|
+    filename = File.basename(path)
+    context "#{filename}" do
+      before do
+        @str = File.read(path, encoding: 'UTF-8')
+      end
+
+      case File.extname(path)
+      when '.json'
+        it "Expected parsed JSON5 to equal parsed JSON" do
+          expect(parseJSON5).to eq(parseJSON)
+        end
+      when '.json5'
+        it 'Expected parsed JSON5 to equal parsed ES5.' do
+          if filename == 'nan.json5'
+            expect(parseJSON5.nan?).to eq(parseES5.nan?)
+          else
+            expect(parseJSON5).to eq(parseES5)
+          end
+        end
+      when '.js'
+        it 'Test case bug expected ES5 parsing not to fail.' do
+          expect{ parseES5 }.not_to raise_exception
+        end
+
+        it 'Expected JSON5 parsing to fail.' do
+          expect{ parseJSON5 }.to raise_exception
+        end
+      when '.txt'
+        it 'Test case bug: expected ES5 parsing to fail.' do
+          expect{ parseES5 }.to raise_exception
+        end
+
+        it 'Expected JSON5 parsing to fail.' do
+          expect{ parseJSON5 }.to raise_exception
+        end
+      end
+    end
+  end
+end

data/spec/parse-cases/arrays/empty-array.json

@@ -0,0 +1 @@
+[]

data/spec/parse-cases/arrays/leading-comma-array.js

@@ -0,0 +1,3 @@
+[
+    ,null
+]

data/spec/parse-cases/arrays/lone-trailing-comma-array.js

@@ -0,0 +1,3 @@
+[
+    ,
+]

data/spec/parse-cases/arrays/no-comma-array.txt

@@ -0,0 +1,4 @@
+[
+    true
+    false
+]

data/spec/parse-cases/arrays/regular-array.json

@@ -0,0 +1,5 @@
+[
+    true,
+    false,
+    null
+]

data/spec/parse-cases/arrays/trailing-comma-array.json5

@@ -0,0 +1,3 @@
+[
+    null,
+]

data/spec/parse-cases/comments/block-comment-following-array-element.json5

@@ -0,0 +1,6 @@
+[
+    false
+    /*
+        true
+    */
+]

data/spec/parse-cases/comments/block-comment-following-top-level-value.json5

@@ -0,0 +1,5 @@
+null
+/*
+    Some non-comment top-level value is needed;
+    we use null above.
+*/

data/spec/parse-cases/comments/block-comment-in-string.json

@@ -0,0 +1 @@
+"This /* block comment */ isn't really a block comment."

data/spec/parse-cases/comments/block-comment-preceding-top-level-value.json5

@@ -0,0 +1,5 @@
+/*
+    Some non-comment top-level value is needed;
+    we use null below.
+*/
+null

data/spec/parse-cases/comments/block-comment-with-asterisks.json5

@@ -0,0 +1,7 @@
+/**
+ * This is a JavaDoc-like block comment.
+ * It contains asterisks inside of it.
+ * It might also be closed with multiple asterisks.
+ * Like this:
+ **/
+true

data/spec/parse-cases/comments/inline-comment-following-array-element.json5

@@ -0,0 +1,3 @@
+[
+    false   // true
+]

data/spec/parse-cases/comments/inline-comment-following-top-level-value.json5

@@ -0,0 +1 @@
+null // Some non-comment top-level value is needed; we use null here.

data/spec/parse-cases/comments/inline-comment-in-string.json

@@ -0,0 +1 @@
+"This inline comment // isn't really an inline comment."

data/spec/parse-cases/comments/inline-comment-preceding-top-level-value.json5

@@ -0,0 +1,2 @@
+// Some non-comment top-level value is needed; we use null below.
+null

data/spec/parse-cases/comments/top-level-block-comment.txt

@@ -0,0 +1,4 @@
+/*
+    This should fail;
+    comments cannot be the top-level value.
+*/

data/spec/parse-cases/comments/top-level-inline-comment.txt

@@ -0,0 +1 @@
+// This should fail; comments cannot be the top-level value.

data/spec/parse-cases/comments/unterminated-block-comment.txt

@@ -0,0 +1,5 @@
+true
+/*
+    This block comment doesn't terminate.
+    There was a legitimate value before this,
+    but this is still invalid JS/JSON5.

data/spec/parse-cases/misc/npm-package.json

@@ -0,0 +1,106 @@
+{
+  "name": "npm",
+  "publishConfig": {
+    "proprietary-attribs": false
+  },
+  "description": "A package manager for node",
+  "keywords": [
+    "package manager",
+    "modules",
+    "install",
+    "package.json"
+  ],
+  "version": "1.1.22",
+  "preferGlobal": true,
+  "config": {
+    "publishtest": false
+  },
+  "homepage": "http://npmjs.org/",
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/isaacs/npm"
+  },
+  "bugs": {
+    "email": "npm-@googlegroups.com",
+    "url": "http://github.com/isaacs/npm/issues"
+  },
+  "directories": {
+    "doc": "./doc",
+    "man": "./man",
+    "lib": "./lib",
+    "bin": "./bin"
+  },
+  "main": "./lib/npm.js",
+  "bin": "./bin/npm-cli.js",
+  "dependencies": {
+    "semver": "~1.0.14",
+    "ini": "1",
+    "slide": "1",
+    "abbrev": "1",
+    "graceful-fs": "~1.1.1",
+    "minimatch": "~0.2",
+    "nopt": "1",
+    "node-uuid": "~1.3",
+    "proto-list": "1",
+    "rimraf": "2",
+    "request": "~2.9",
+    "which": "1",
+    "tar": "~0.1.12",
+    "fstream": "~0.1.17",
+    "block-stream": "*",
+    "inherits": "1",
+    "mkdirp": "0.3",
+    "read": "0",
+    "lru-cache": "1",
+    "node-gyp": "~0.4.1",
+    "fstream-npm": "0 >=0.0.5",
+    "uid-number": "0",
+    "archy": "0",
+    "chownr": "0"
+  },
+  "bundleDependencies": [
+    "slide",
+    "ini",
+    "semver",
+    "abbrev",
+    "graceful-fs",
+    "minimatch",
+    "nopt",
+    "node-uuid",
+    "rimraf",
+    "request",
+    "proto-list",
+    "which",
+    "tar",
+    "fstream",
+    "block-stream",
+    "inherits",
+    "mkdirp",
+    "read",
+    "lru-cache",
+    "node-gyp",
+    "fstream-npm",
+    "uid-number",
+    "archy",
+    "chownr"
+  ],
+  "devDependencies": {
+    "ronn": "https://github.com/isaacs/ronnjs/tarball/master"
+  },
+  "engines": {
+    "node": "0.6 || 0.7 || 0.8",
+    "npm": "1"
+  },
+  "scripts": {
+    "test": "node ./test/run.js",
+    "prepublish": "npm prune; rm -rf node_modules/*/{test,example,bench}*; make -j4 doc",
+    "dumpconf": "env | grep npm | sort | uniq"
+  },
+  "licenses": [
+    {
+      "type": "MIT +no-false-attribs",
+      "url": "http://github.com/isaacs/npm/raw/master/LICENSE"
+    }
+  ]
+}