Map-2-JSON.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map-2-JSON\n",
    "\n",
    "This is the translation of an older [Gist](https://gist.github.com/rdmueller/793d262862270eda8d3a0b5c2e9e46da) (which was inspired by jupyter) to a jupyter notebook with [beakerx](https://github.com/twosigma/beakerx) and [binder](https://mybinder.org/).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem: \n",
    "\n",
    "Languages like tcl can simply switch between the String representation of a map or list and the object itself. In Groovy, this could theoretically work, but it doesn't:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def list1 = [1,2,3]\n",
    "def list2 = [\"1, 2, 3\"]\n",
    "assert         list1             !=         list2\n",
    "assert         list1.toString()  ==         list2.toString()\n",
    "assert Eval.me(list1.toString()) instanceof List\n",
    "assert Eval.me(list2.toString()) instanceof List\n",
    "assert Eval.me(list1.toString()) == Eval.me(list2.toString())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solution:\n",
    "Groovy has several ways to serialize a map or list. One popular way it to convert it to JSON\n",
    "http://groovy-lang.org/json.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import groovy.json.*\n",
    "map = [\n",
    "            list:[1,2,3],\n",
    "            integer: 5,\n",
    "            bigDecimal: 3.1415,\n",
    "            string: \"yes\",\n",
    "            boolean: true,\n",
    "            //date: new Date(0)\n",
    "      ]\n",
    "mapAsJson = JsonOutput.toJson(map)\n",
    "assert mapAsJson == '{\"list\":[1,2,3],\"integer\":5,\"bigDecimal\":3.1415,\"string\":\"yes\",\"boolean\":true}'\n",
    "assert new JsonSlurper().parseText(mapAsJson) instanceof Map\n",
    "assert new JsonSlurper().parseText(mapAsJson) == map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as you can see, the entry with type \"Date\" is commented out. Unfortunately, the conversion isn't bi-directional for all data types\n",
    "\n",
    "another popular way to serialze a map is YAML. YAML has the slight drawback that it needs an external library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@Grab(\"org.yaml:snakeyaml:1.16\")\n",
    "import org.yaml.snakeyaml.Yaml\n",
    "\n",
    "def mapAsYaml = new Yaml().dump(map)\n",
    "assert mapAsYaml == \"\"\"list: [1, 2, 3]\n",
    "integer: 5\n",
    "bigDecimal: 3.1415\n",
    "string: 'yes'\n",
    "boolean: true\n",
    "\"\"\"\n",
    "assert new Yaml().load(mapAsYaml) instanceof Map\n",
    "assert new Yaml().load(mapAsYaml) == map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both ways work fine. The main difference is that the String representation of JSON is one line by default where YAML is distributed over several lines.\n",
    "\n",
    "In order to make these serializations easier to use, we can make use of metaprogramming:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import groovy.json.*\n",
    "    \n",
    "String.metaClass.toMap {->\n",
    "    new JsonSlurper().parseText(delegate)\n",
    "}\n",
    "assert '{\"list\":[1,2,3],\"integer\":5,\"bigDecimal\":3.1415,\"string\":\"yes\",\"boolean\":true}'.toMap() == map\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, the toString() can't be overwritten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Map.metaClass.toString {->\n",
    "    JsonOutput.toJson(delegate)\n",
    "}\n",
    "assert '{\"list\":[1,2,3],\"integer\":5,\"bigDecimal\":3.1415,\"string\":\"yes\",\"boolean\":true}'         != map.toString()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...but a toJson() method can be created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import groovy.json.*\n",
    "    \n",
    "Map.metaClass.toJson {->\n",
    "    JsonOutput.toJson(delegate)\n",
    "}\n",
    "assert '{\"list\":[1,2,3],\"integer\":5,\"bigDecimal\":3.1415,\"string\":\"yes\",\"boolean\":true}'         == map.toJson()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "//btw: since YAML is a superset of JSON, you can deserialize JSON with YAML:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import org.yaml.snakeyaml.Yaml\n",
    "\n",
    "assert new Yaml().load(mapAsJson) == map\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "//but not the other way around.\n",
    "\n",
    "//Groovy version used: 2.4.5"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Groovy",
   "language": "groovy",
   "name": "groovy"
  },
  "language_info": {
   "codemirror_mode": "groovy",
   "file_extension": ".groovy",
   "mimetype": "",
   "name": "Groovy",
   "nbconverter_exporter": "",
   "version": "2.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}