jsonstat2jsonstat

#!/usr/bin/env node

const
	argv=require("yargs")
		.version()
		.usage("Usage:\n  $0 [input filename] [output filename]\n  $0 < [input] > [output] -t")
		.example("$0 old.json v20.json", "converts JSON-stat file old.json into JSON-stat 2.0 (v20.json).")
		.example("$0 < old.json > v20.json -t", "converts JSON-stat stream old.json into a JSON-stat 2.0 stream (v20.json).")
		.alias("f", "filter")
		.describe("f", "Filter string (for example: area=DE,year=2014)")
		.boolean("m")
		.alias("m", "modify")
		.describe("m", "Modify value and status type")
		.boolean("o")
		.alias("o", "ovalue")
		.describe("o", "Type of value: object instead of array")
		.boolean("s")
		.alias("s", "ostatus")
		.describe("s", "Type of status: object instead of array")
		.boolean("t")
		.alias("t", "stream")
		.describe("t", "Enable the stream interface")
		.help("h")
		.alias("h", "help")
		.argv
	,

	inout=require("./inout"),

	arr2obj=function(o,p){ //o object p property
		let ret={};
		if(Object.prototype.toString.call(o[p]) === '[object Array]'){
			o[p].forEach(function(e,i){
				if(e!==null){
					ret[String(i)]=e;
				}
			});
			return ret;
		}
		return o[p];
	},

	obj2arr=function(o,p){	//o object p property
		let
			v,
			ret=[],
			i=o.size.reduce(function(a, b){ return a * b;});
		;

		if(typeof o[p] === 'object' && Object.prototype.toString.call(o[p]) !== '[object Array]'){
			for(;i--;){
				v=o[p][String(i)];
				ret[i]=typeof v!=="undefined" ? v : null;
			}
			return ret;
		}

		return o[p];
	},

	modify=function(tree, attr){
		const
			arg=(attr==="value") ? argv.ovalue : argv.ostatus,
			typ=Object.prototype.toString.call(tree[attr])
		;

		if(
			//value/status is array but object was requested
			(typ==="[object Array]" && arg)
			||
			//value/status is object but array was requested
			(typ!=="[object Array]" && !arg)
		){
			const newcont=arg ? arr2obj(tree, attr) : obj2arr(tree, attr);
			delete tree[attr];
			tree[attr]=newcont;
		}
	},

	stringify=function(json){
		const tree=json.__tree__;

		//if v<2.0 convert to 2.0
		if(!tree.hasOwnProperty("id")){
			tree.version="2.0";
			if(!tree.hasOwnProperty("class")){
				tree.class="dataset";
			}

			tree.id=tree.dimension.id;
			tree.size=tree.dimension.size;
			delete tree.dimension.id;
			delete tree.dimension.size;

			if(tree.dimension.hasOwnProperty("role")){
				tree.role=tree.dimension.role;
				delete tree.dimension.role;
			}
		}

		if(tree.hasOwnProperty("status") && tree.status===null){
			delete tree.status;
		}

		if(tree.hasOwnProperty("role")){
			delete tree.role.classification;

			["geo", "time", "metric"].forEach(function(e){
				if(tree.role[e]===null){
					delete tree.role[e];
				}
			});
		}

		if(argv.modify){
			modify(tree, "value");
			if(tree.hasOwnProperty("status")){
				modify(tree, "status");
			}
		}

		return JSON.stringify(tree);
	},

	callback=function(contents){
		const filter=argv.filter;

		let
			arrfil,
			subset
		;

		//filter is not required: if not specified (no -f or -f without string) don't slice
		if(!filter || filter===true){
			return stringify( inout.dataset(contents) );
		}

		if(filter.indexOf("=")===-1){
			console.error("Error: The filter has not been specified correctly (missing =).");
			process.exit(1);
		}

		arrfil=filter.split(",").map(function(e){
			return e.split("=");
		});

		subset=inout.dataset(contents).Slice(arrfil);
		if(subset===null){
			console.error("Error: The input does not containt valid JSON-stat or the filters are not valid.");
			process.exit(1);
		}else{
			return stringify(subset);
		}
	}
;

inout.main(argv, callback, true);