json-next 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4bc912a3a1cfbfee8f003ec071192735ec5f638
+  data.tar.gz: 493c00f3d34dc0c3f868f28d52e254b07686b4c5
+SHA512:
+  metadata.gz: 717d9c8b9bdc8f63fb8abbc2de0e76b6d1355bb17edf30702c61449ff5ce9f739d1f9f3bac5c11eeb169d2488a04ef17f9624c63fdb1e614d713ab7bbdb19b1a
+  data.tar.gz: a57f3d1a612907827b3ae7decbff6bd55d963f214499a551fe166d6a427029d02f5a0ceee7b28ded0ee269a31282b14ca731beae9f007174ae6f7197626f1cb2

data/HISTORY.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2017-07-06
+
+* Everything is new. First release.

data/Manifest.txt

@@ -0,0 +1,15 @@
+HISTORY.md
+Manifest.txt
+README.md
+Rakefile
+lib/json/next.rb
+lib/json/next/commata.rb
+lib/json/next/parser/hanson.rb
+lib/json/next/parser/son.rb
+lib/json/next/pattern.rb
+lib/json/next/version.rb
+test/helper.rb
+test/test_commata.rb
+test/test_parser_hanson.rb
+test/test_parser_son.rb
+test/test_version.rb

data/README.md

@@ -0,0 +1,256 @@
+# jasony
+
+jasony gem -  read generation y / next generation json versions (HanSON, SON, etc.) with comments, unquoted keys, multi-line strings, trailing commas, optional commas, and more
+
+
+* home  :: [github.com/datatxt/jasony](https://github.com/datatxt/jasony)
+* bugs  :: [github.com/datatxt/jasony/issues](https://github.com/datatxt/jasony/issues)
+* gem   :: [rubygems.org/gems/jasony](https://rubygems.org/gems/jasony)
+* rdoc  :: [rubydoc.info/gems/jasony](http://rubydoc.info/gems/jasony)
+
+
+
+
+## Usage - `HANSON.parse`,  `SON.parse`
+
+[HanSON](#hanson) •
+[SON](#son)
+
+
+### HanSON
+
+_HanSON - JSON for Humans by Tim Jansen et al_
+
+HanSON is an extension of JSON  with a few simple additions to the spec:
+
+- quotes for strings are optional if they follow JavaScript identifier rules.
+- you can alternatively use backticks, as in ES6's template string literal, as quotes for strings.
+  A backtick-quoted string may span several lines and you are not required to escape regular quote characters,
+  only backticks. Backslashes still need to be escaped, and all other backslash-escape sequences work like in
+  regular JSON.
+- for single-line strings, single quotes (`''`) are supported in addition to double quotes (`""`)
+- you can use JavaScript comments, both single line (`//`) and multi-line comments (`/* */`), in all places where JSON allows whitespace.
+- Commas after the last list element or object property will be ignored.
+
+
+Example:
+
+``` js
+{
+  listName: "Sesame Street Monsters", // note that listName needs no quotes
+  content: [
+    {
+      name: "Cookie Monster",
+      /* Note the template quotes and unescaped regular quotes in the next string */
+      background: `Cookie Monster used to be a
+monster that ate everything, especially cookies.
+These days he is forced to eat "healthy" food.`
+    }, {
+      // You can single-quote strings too:
+      name: 'Herry Monster',
+      background: `Herry Monster is a furry blue monster with a purple nose.
+He's mostly retired today.`
+    },    // don't worry, the trailing comma will be ignored
+   ]
+}
+```
+
+Use `HANSON.convert` to convert HanSON text to ye old' JSON text:
+
+``` json
+{
+  "listName": "Sesame Street Monsters",       
+  "content": [
+    { "name": "Cookie Monster",
+       "background": "Cookie Monster used to be a\n ... to eat \"healthy\" food."
+    },
+    { "name": "Herry Monster",
+      "background": "Herry Monster is a furry blue monster with a purple nose.\n ... today."
+    }
+  ]
+}
+```
+
+Use `HANSON.parse` instead of `JSON.parse` to parse text to ruby hash / array / etc.:
+
+``` ruby
+{
+  "listName" => "Sesame Street Monsters",
+  "content" => [
+     { "name" => "Cookie Monster",
+       "background" => "Cookie Monster used to be a\n ... to eat \"healthy\" food."
+     },
+     { "name" => "Herry Monster",
+       "background" => "Herry Monster is a furry blue monster with a purple nose.\n ... today."
+    }
+  ]
+}
+```
+
+
+
+### SON
+
+_SON - Simple Object Notation by Aleksander Gurin et al_
+
+Simple data format similar to JSON, but with some minor changes:
+
+- comments starts with `#` sign and ends with newline (`\n`)
+- comma after an object key-value pair is optional
+- comma after an array item is optional
+
+JSON is compatible with SON in a sense that
+JSON data is also SON data, but not vise versa.
+
+Example:
+
+```
+{
+  # Personal information
+
+  "name": "Alexander Grothendieck"
+  "fields": "mathematics"
+  "main_topics": [
+    "Etale cohomology"
+    "Motives"
+    "Topos theory"
+    "Schemes"
+  ]
+  "numbers": [1 2 3 4]
+  "mixed": [1.1 -2 true false null]
+}
+```
+
+Use `SON.convert` to convert SON text to ye old' JSON text:
+
+``` json
+{
+  "name": "Alexander Grothendieck",
+  "fields": "mathematics",
+  "main_topics": [
+    "Etale cohomology",
+    "Motives",
+    "Topos theory",
+    "Schemes"
+  ],
+  "numbers": [1, 2, 3, 4],
+  "mixed": [1.1, -2, true, false, null]
+}
+```
+
+Use `SON.parse` instead of `JSON.parse` to parse text to ruby hash / array / etc.:
+
+``` ruby
+
+{
+  "name" => "Alexander Grothendieck",
+  "fields" => "mathematics",
+  "main_topics" =>
+    ["Etale cohomology", "Motives", "Topos theory", "Schemes"],
+  "numbers" => [1, 2, 3, 4],
+  "mixed" => [1.1, -2, true, false, nil]    
+}
+```
+
+
+
+### Live Examples
+
+
+``` ruby
+require 'jasony'
+
+text1 =<<TXT
+{
+  listName: "Sesame Street Monsters", // note that listName needs no quotes
+  content: [
+    {
+      name: "Cookie Monster",
+      /* Note the template quotes and unescaped regular quotes in the next string */
+      background: `Cookie Monster used to be a
+monster that ate everything, especially cookies.
+These days he is forced to eat "healthy" food.`
+    }, {
+      // You can single-quote strings too:
+      name: 'Herry Monster',
+      background: `Herry Monster is a furry blue monster with a purple nose.
+He's mostly retired today.`
+    },    // don't worry, the trailing comma will be ignored
+   ]
+}
+TXT
+
+pp HANSON.parse( text1 )  # note: is the same as JSON.parse( HANSON.convert( text ))
+```
+
+resulting in:
+
+``` ruby
+{
+  "listName" => "Sesame Street Monsters",
+  "content" => [
+     { "name" => "Cookie Monster",
+       "background" => "Cookie Monster used to be a\n ... to eat \"healthy\" food."
+     },
+     { "name" => "Herry Monster",
+       "background" => "Herry Monster is a furry blue monster with a purple nose.\n ... today."
+    }
+  ]
+}
+```
+
+and
+
+``` ruby
+
+text2 =<<TXT
+{
+  # Personal information
+
+  "name": "Alexander Grothendieck"
+  "fields": "mathematics"
+  "main_topics": [
+    "Etale cohomology"
+    "Motives"
+    "Topos theory"
+    "Schemes"
+  ]
+  "numbers": [1 2 3 4]
+  "mixed": [1.1 -2 true false null]
+}
+TXT
+
+pp SON.parse( text2 )  # note: is the same as JSON.parse( SON.convert( text ))
+```
+
+resulting in:
+
+``` ruby
+{
+  "name" => "Alexander Grothendieck",
+  "fields" => "mathematics",
+  "main_topics" =>
+    ["Etale cohomology", "Motives", "Topos theory", "Schemes"],
+  "numbers" => [1, 2, 3, 4],
+  "mixed" => [1.1, -2, true, false, nil]    
+}
+```
+
+
+
+## More JSON Formats
+
+See the [Awesome JSON (What's Next?)](https://github.com/datatxt/awesome-json-next) collection / page.
+
+
+
+## License
+
+![](https://publicdomainworks.github.io/buttons/zero88x31.png)
+
+The `jasony` scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+## Questions? Comments?
+
+Post them to the [wwwmake forum](http://groups.google.com/group/wwwmake). Thanks!

data/Rakefile

@@ -0,0 +1,26 @@
+require 'hoe'
+require './lib/json/next/version.rb'
+
+Hoe.spec 'json-next' do
+
+  self.version = JSON::Next::VERSION
+
+  self.summary = 'json-next - read generation y / next generation json versions (HanSON, SON, etc.) with comments, unquoted keys, multi-line strings, trailing commas, optional commas, and more'
+  self.description = summary
+
+  self.urls    = ['https://github.com/datatxt/json-next']
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'ruby-talk@ruby-lang.org'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'HISTORY.md'
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+   required_ruby_version: '>= 1.9.2'
+  }
+
+end

data/lib/json/next.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'json'
+require 'strscan'   ## StringScanner
+require 'pp'
+
+
+# our own code
+require 'json/next/version'   # note: let version always go first
+require 'json/next/pattern'    #  shared utils for "custom" parser
+require 'json/next/commata'
+
+require 'json/next/parser/hanson'
+require 'json/next/parser/son'
+
+
+
+# say hello
+puts JSON::Next.banner    if defined?( $RUBYLIBS_DEBUG )

data/lib/json/next/commata.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+module JSON
+  module Next
+
+
+### auto-add commas for objects and arrays
+class Commata
+
+
+## convenience helper
+def self.convert( str, opts={} )
+   self.new.convert( str, opts )
+end
+
+
+def convert( str, opts={} )
+   @debug  = opts.fetch( :debug, false )
+   @out    = ""
+   @buffer = StringScanner.new( str )
+
+   skip_whitespaces
+   parse_value
+   @out
+end
+
+
+def debug?() @debug; end
+
+
+
+def skip_whitespaces
+  @buffer.skip( /[ \t\n]*/ )    ## skip trailing WHITESPACE
+end
+
+
+def parse_string
+
+   if @buffer.peek(1) == '"'   ## double quote
+       @buffer.getch  # consume double quote
+       value = @buffer.scan_until( /(?=")/)  ## fix: allow escaped double quote e.g. \" too!!!
+       @buffer.getch  # consume double quote
+
+       puts %{string value >>#{value}<<} if debug?
+       @out << ' "'
+       @out << value
+       @out << '" '
+
+       skip_whitespaces
+   else
+     puts "!! format error: string literal - expected opening quote (\") - rest is >>#{@buffer.rest}<<"
+   end
+end
+
+
+
+def parse_object
+
+ if @buffer.peek(1) == '{'
+     @buffer.getch   # consume '{'
+     @out << ' { '
+     skip_whitespaces
+
+    if @buffer.peek(1) == '}'    ## empty object?
+      @buffer.getch   # consume '{'
+      @out << ' } '
+      skip_whitespaces
+      return
+    end
+
+    loop do
+      parse_string
+      if @buffer.peek(1) == ':'
+         @buffer.getch   # consume ':'
+         @out << ' : '
+         skip_whitespaces
+
+         parse_value
+         if @buffer.peek(1) == '}'
+           @buffer.getch   # consume '}'
+           @out << ' } '
+           skip_whitespaces
+           return   ## use break - why? why not?
+         else
+           if @buffer.peek(1) == ','
+              @buffer.getch   # consume ','
+              @out << ' , '
+              skip_whitespaces
+           else
+             puts "object literal - auto-add comma for key-value pair" if debug?
+             @out << ' , '
+           end
+         end
+      else
+        puts "!! format error: object literal - expected colon (:) - rest is >>#{@buffer.rest}<<"
+      end
+    end
+ else
+     puts "!! format error: object literal - expected curly open bracket ({) - rest is >>#{@buffer.rest}<<"
+ end
+end  # method parse_object
+
+
+
+def parse_array
+
+ if @buffer.peek(1) == '['
+     @buffer.getch   # consume '['
+     @out << ' [ '
+     skip_whitespaces
+
+    if @buffer.peek(1) == ']'    ## empty array?
+      @buffer.getch   # consume ']'
+      @out << ' ] '
+      skip_whitespaces
+      return
+    end
+
+    loop do
+         parse_value
+         if @buffer.peek(1) == ']'
+           @buffer.getch   # consume ']'
+           @out << ' ] '
+           skip_whitespaces
+           return   ## use break - why? why not?
+         else
+           if @buffer.peek(1) == ','
+              @buffer.getch   # consume ','
+              @out << ' , '
+              skip_whitespaces
+           else
+             puts "array literal - auto-add comma for value" if debug?
+             @out << ' , '
+           end
+         end
+    end
+ else
+     puts "!! format error: array literal - expected square open bracket ([) - rest is >>#{@buffer.rest}<<"
+ end
+end  # method parse_array
+
+
+
+def parse_value
+  if @buffer.peek(1) == '{'
+     parse_object
+  elsif @buffer.peek(1) == '['
+     parse_array
+  elsif @buffer.peek(1) == '"'
+     parse_string
+  else
+     ## assume number or literal/identifier
+    value = @buffer.scan( /[_$a-zA-Z0-9.+\-]+/ )
+    puts %{literal value >>#{value}<<}  if debug?
+    @out << " "
+    @out << value
+    @out << " "
+
+    skip_whitespaces
+  end
+
+  ## todo/fix: check if eof reached ?? if not report warning - more data available??
+  ##  wrap in object ({}) or array ([])
+end
+
+
+end  # class Commata
+
+
+  end # module Next
+end # module JSON

data/lib/json/next/parser/hanson.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+###
+#  based on github.com/timjansen/hanson
+#   Thanks to Tim Jansen
+
+
+module HANSON
+
+
+  BACKTICK_ML_QUOTE = JSON::Next::BACKTICK_ML_QUOTE
+  SINGLE_QUOTE      = JSON::Next::SINGLE_QUOTE
+  DOUBLE_QUOTE      = JSON::Next::DOUBLE_QUOTE
+
+  CLANG_ML_COMMENT  = JSON::Next::CLANG_ML_COMMENT
+  CLANG_COMMENT     = JSON::Next::CLANG_COMMENT
+
+  KEYWORDS          = JSON::Next::KEYWORDS
+  IDENTIFIER        = JSON::Next::IDENTIFIER
+  TRAILING_COMMA    = JSON::Next::TRAILING_COMMA
+
+  UNESCAPE_MAP      = JSON::Next::UNESCAPE_MAP
+  ML_ESCAPE_MAP     = JSON::Next::ML_ESCAPE_MAP
+
+
+
+  def self.strip_comments( text )   ## pass 1
+    text.gsub( /#{BACKTICK_ML_QUOTE}|#{SINGLE_QUOTE}|#{DOUBLE_QUOTE}|#{CLANG_ML_COMMENT}|#{CLANG_COMMENT}/ox ) do |match|
+       ## puts "match: >>#{match}<< : #{match.class.name}"
+       if match[0] == ?/    ## comments start with // or /*
+         ## puts "!!! removing comments"
+         ''    ## remove / strip comments
+       else
+         match
+       end
+     end
+  end
+
+
+  def self.normalize_quotes( text )  ## pass 2
+     text.gsub( /#{BACKTICK_ML_QUOTE}|#{SINGLE_QUOTE}|#{DOUBLE_QUOTE}/ox ) do |match|
+       ## puts "match: >>#{match}<< : #{match.class.name}"
+
+       m = Regexp.last_match
+       if m[:backtick_ml_quote]
+         ## puts "!!! ml_quote -- convert to double quotes"
+         str = m[:backtick_ml_quote]
+         str = str.gsub( /\\./ ) {|r| UNESCAPE_MAP[r] || r }
+         str = str.gsub( /[\n\r\t"]/ ) { |r| ML_ESCAPE_MAP[r] }
+         '"' + str + '"'
+       elsif m[:single_quote]
+         ## puts "!!! single_quote -- convert to double quotes"
+         str = m[:single_quote]
+         str = str.gsub( /\\./ ) {|r| UNESCAPE_MAP[r] || r }
+         str = str.gsub( /"/, %{\\"} )
+         '"' + str + '"'
+       else
+         match
+       end
+    end
+  end
+
+
+  def self.convert( text )
+
+    # text is the HanSON string to convert.
+
+    # todo: add keep_line_numbers options - why? why not?
+    #  see github.com/timjansen/hanson
+
+    ## pass 1: remove/strip comments
+    text = strip_comments( text )
+
+    ## pass 2: requote/normalize quotes
+    text = normalize_quotes( text )
+
+    ## pass 3: quote unquoted and remove trailing commas
+    text = text.gsub( /#{KEYWORDS}|#{IDENTIFIER}|#{DOUBLE_QUOTE}|#{TRAILING_COMMA}/ox ) do |match|
+       ## puts "match: >>#{match}<< : #{match.class.name}"
+
+       m = Regexp.last_match
+       if m[:identifier]
+         ## puts "!!! identfier -- wrap in double quotes"
+         '"' + m[:identifier] + '"'
+       elsif m[:trailing_comma]
+         ## puts "!!! trailing comma -- remove"
+         ''
+       else
+         match
+       end
+    end
+
+    text
+  end
+
+
+  def self.parse( text )
+    JSON.parse( self.convert( text ) )
+  end
+
+end # module HANSON

data/lib/json/next/parser/son.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+###
+#  based on github.com/aleksandergurin/simple-object-notation
+#   Thanks to Aleksander Gurin
+
+
+module SON
+
+
+  DOUBLE_QUOTE      = JSON::Next::DOUBLE_QUOTE
+
+  SHELL_COMMENT     = JSON::Next::SHELL_COMMENT
+
+
+  def self.strip_comments( text )   ## pass 1
+    text.gsub( /#{DOUBLE_QUOTE}|#{SHELL_COMMENT}/ox ) do |match|
+       ## puts "match: >>#{match}<< : #{match.class.name}"
+       if match[0] == ?#    ## comments start with #
+         ## puts "!!! removing comments"
+         ''    ## remove / strip comments
+       else
+         match
+       end
+     end
+  end
+
+
+
+
+  def self.convert( text )
+
+    # text is the SON string to convert.
+
+    text = strip_comments( text )    ## pass 1
+    text = JSON::Next::Commata.convert( text )  ## pass 2 - auto-add (missing optional) commas
+    text
+  end
+
+
+  def self.parse( text )
+    JSON.parse( self.convert( text ) )
+  end
+
+end # module SON

data/lib/json/next/pattern.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+module JSON
+  module Next
+
+  ## note: regex pattern \\ needs to get escaped twice, thus, \\.
+  ##  and for literal \\ use \\\\\.
+
+  ## todo: check for newlines   [^] incl. newline ?
+
+  ## note: add named captures for "inner" unquotes string values
+
+  ###############
+  ##### quotes
+
+
+  BACKTICK_ML_QUOTE  = %< ` (?<backtick_ml_quote>
+                                (?:
+                                  \\\\. | [^`]
+                                )*
+                            )
+                          `
+                        >
+
+  ## => \\\\.    --  allow backslash escapes e.g. \n \t \\ etc.
+  ## => [^`]     --  everything except backquote
+
+  ## todo/fix - check if [^`] includes/matches newline too (yes)? -- add \n for multi-line!
+
+
+  SINGLE_QUOTE       = %< ' (?<single_quote>
+                              (?:
+                                 \\\\. | [^']
+                              )*
+                            )
+                         '
+                        >
+
+  DOUBLE_QUOTE       = %< " (?<double_quote>
+                              (?:
+                                \\\\. | [^"]
+                              )*
+                            )
+                          "
+                        >
+
+
+  #######################
+  #### comments
+
+  CLANG_ML_COMMENT     = %< /\\*
+                              .*?
+                             \\*/
+                          >
+
+  ## use . instead of [^] - why? why not?
+  ## note: check if . incl. newlines too (only in multi-line (m) option - why? why not??
+  ##   fix/todo: include newline!!! \n - for multi-line!!!
+
+  ##  note: *? is NON-greedy
+
+
+  CLANG_COMMENT        = %<  //
+                             .*?
+                             (?:
+                               \\n | $
+                             )
+                         >
+
+  ## note: check if . incl. newlines too (only in multi-line (m) option - why? why not??
+  ##  note: *? is NON-greedy
+
+
+  SHELL_COMMENT        = %<  [#]
+                             .*?
+                             (?:
+                               \\n | $
+                             )
+                         >
+
+## note: use [#] instead of # to avoid confusion with # comment in regex
+
+
+
+
+  KEYWORDS       = %<
+                      (?:
+                         true | false | null
+                      )
+                      (?=
+                          [^\\w_$] | $
+                      )
+                    >
+
+  IDENTIFIER     = %<
+                      (?<identifier>
+                         [a-zA-Z_$]
+                         [\\w_$]*
+                      )
+                    >
+
+  TRAILING_COMMA = %<
+                      (?<trailing_comma>,)
+                      (?=
+                        \\s*
+                        [}\\]]
+                      )
+                    >
+
+
+
+  UNESCAPE_MAP = {
+    %<\\"> => %<">,     ## "\\\"" => "\"",
+    %<\\`> => %<`>,     ## "\\`"  => "`",
+    %<\\'> => %<'>      ## "\\'"  => "'"
+  }
+
+  ML_ESCAPE_MAP = {
+    %<\n> => %<\\n>,    ## "\n" => "\\n",
+    %<\r> => %<\\r>,    ## "\r" => "\\r",
+    %<\t> => %<\\t>,    ## "\t" => "\\t",
+    %<">  => %<\\">     ## "\"" => "\\\""
+  }
+
+
+  end # module Next
+end # module JSON

data/lib/json/next/version.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module JSON
+  module Next
+
+  MAJOR = 1    ## todo: namespace inside version or something - why? why not??
+  MINOR = 1
+  PATCH = 0
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "json-next/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+  end
+
+  def self.root
+    "#{File.expand_path( File.dirname(File.dirname(File.dirname(File.dirname(__FILE__)))) )}"
+  end
+
+  end # module Next
+end # module JSON

data/test/helper.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+## minitest setup
+require 'minitest/autorun'
+
+
+$RUBYLIBS_DEBUG = true
+
+## our own code
+require 'json/next'

data/test/test_commata.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_commata.rb
+
+
+require 'helper'
+
+
+class TestCommata < MiniTest::Test
+
+  def test_commata
+
+    sample1a =<<TXT
+     {
+      "name": "Alexander Grothendieck"
+      "fields": "mathematics"
+      "main_topics": [
+          "Etale cohomology"
+          "Motives"
+          "Topos theory"
+          "Schemes"
+      ]
+     }
+TXT
+
+  exp_sample1b = {
+    "name" => "Alexander Grothendieck",
+    "fields" => "mathematics",
+    "main_topics" =>
+      ["Etale cohomology", "Motives", "Topos theory", "Schemes"]
+  }
+
+
+    sample2a =<<TXT
+     {
+      "nested": {
+        "name": "Alexander Grothendieck"
+        "fields": "mathematics"
+        "array": ["one" "two"]  }
+      "numbers": [1 2 3 4 5]
+      "more_numbers": [1.1 2.0 0.3 4.444 -5.1]
+      "mixed": [1 true false null]
+     }
+TXT
+
+    sample2a1 =<<TXT
+     {
+      "nested": {
+        "name": "Alexander Grothendieck",
+        "fields": "mathematics",
+        "array": ["one", "two"]  },
+      "numbers": [1, 2, 3, 4, 5],
+      "more_numbers": [1.1, 2.0, 0.3, 4.444, -5.1],
+      "mixed": [1, true, false, null]
+     }
+TXT
+
+
+
+   exp_sample2b = {
+       "nested" => {
+         "name" => "Alexander Grothendieck",
+         "fields" => "mathematics",
+         "array" => ["one", "two"]
+       },
+       "numbers" => [1, 2, 3, 4, 5],
+       "more_numbers" => [1.1, 2.0, 0.3, 4.444, -5.1],
+       "mixed" => [1, true, false, nil]
+    }
+
+
+    sample1b = JSON::Next::Commata.convert( sample1a, debug: true )
+    puts sample1b
+
+    assert_equal exp_sample1b, JSON.parse( sample1b )
+
+
+    sample2b = JSON::Next::Commata.convert( sample2a, debug: true )
+    puts sample2b
+
+    assert_equal exp_sample2b, JSON.parse( sample2b )
+
+
+    sample2b1 = JSON::Next::Commata.convert( sample2a1, debug: true )
+    puts sample2b1
+
+    assert_equal exp_sample2b, JSON.parse( sample2b1 )
+  end
+
+end

data/test/test_parser_hanson.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parser_hanson.rb
+
+
+require 'helper'
+
+
+class TestParser < MiniTest::Test
+
+  def test_hanson
+    exp_sample1 = {
+      "listName"=>"Sesame Street Monsters",
+      "content"=>
+        [{"name"=>"Cookie Monster",
+          "background"=> "Cookie Monster used to be a\n    monster that ate everything, especially cookies.\n    These days he is forced to eat \"healthy\" food."
+         },
+         {"name"=>"Herry Monster",
+          "background"=> "Herry Monster is a furry blue monster with a purple nose.\n    He's mostly retired today."
+        }
+       ]}
+
+    sample1 =<<TXT
+    {
+      listName: "Sesame Street Monsters", // note that listName needs no quotes
+      content: [
+        {
+          name: "Cookie Monster",
+          /* Note the template quotes and unescaped regular quotes in the next string */
+          background: `Cookie Monster used to be a
+    monster that ate everything, especially cookies.
+    These days he is forced to eat "healthy" food.`
+        }, {
+          // You can single-quote strings too:
+          name: 'Herry Monster',
+          background: `Herry Monster is a furry blue monster with a purple nose.
+    He's mostly retired today.`
+        },    // don't worry, the trailing comma will be ignored
+       ]
+    }
+TXT
+
+    puts HANSON.convert( sample1 )
+
+    pp HANSON.parse( sample1 )
+
+    assert_equal exp_sample1, HANSON.parse( sample1 )
+  end
+
+end

data/test/test_parser_son.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parser_son.rb
+
+
+require 'helper'
+
+
+class TestParserSon < MiniTest::Test
+
+  def test_son
+    exp_sample1 = {
+       "name"=>"Alexander Grothendieck",
+       "fields"=>"mathematics",
+       "main_topics"=>
+         ["Etale cohomology", "Motives", "Topos theory", "Schemes"]
+    }
+
+    sample1 =<<TXT
+     {
+        # Personal information
+
+        "name": "Alexander Grothendieck"
+        "fields": "mathematics"
+        "main_topics": [
+            "Etale cohomology"
+            "Motives"
+            "Topos theory"
+            "Schemes"
+        ]
+    }
+TXT
+
+    puts SON.convert( sample1 )
+
+    assert_equal exp_sample1, SON.parse( sample1 )
+  end
+
+end

data/test/test_version.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_version.rb
+
+
+require 'helper'
+
+
+class TestVersion < MiniTest::Test
+
+
+  def test_version
+
+    pp JSON::Next::UNESCAPE_MAP
+    pp JSON::Next::ML_ESCAPE_MAP
+
+    pp JSON::Next::BACKTICK_ML_QUOTE
+    puts JSON::Next::BACKTICK_ML_QUOTE
+    pp JSON::Next::SINGLE_QUOTE
+    puts JSON::Next::SINGLE_QUOTE
+    pp JSON::Next::DOUBLE_QUOTE
+    puts JSON::Next::DOUBLE_QUOTE
+
+    pp JSON::Next::CLANG_ML_COMMENT
+    puts JSON::Next::CLANG_ML_COMMENT
+    pp JSON::Next::CLANG_COMMENT
+    puts JSON::Next::CLANG_COMMENT
+
+
+    puts JSON::Next::VERSION
+    assert true
+    ## assume everything ok if get here
+  end
+
+end # class TestVersion

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: json-next
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.15'
+description: json-next - read generation y / next generation json versions (HanSON,
+  SON, etc.) with comments, unquoted keys, multi-line strings, trailing commas, optional
+  commas, and more
+email: ruby-talk@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.md
+- Manifest.txt
+- README.md
+files:
+- HISTORY.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/json/next.rb
+- lib/json/next/commata.rb
+- lib/json/next/parser/hanson.rb
+- lib/json/next/parser/son.rb
+- lib/json/next/pattern.rb
+- lib/json/next/version.rb
+- test/helper.rb
+- test/test_commata.rb
+- test/test_parser_hanson.rb
+- test/test_parser_son.rb
+- test/test_version.rb
+homepage: https://github.com/datatxt/json-next
+licenses:
+- Public Domain
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: json-next - read generation y / next generation json versions (HanSON, SON,
+  etc.) with comments, unquoted keys, multi-line strings, trailing commas, optional
+  commas, and more
+test_files: []