semantic/prototype/Doubt/JSONParser.swift

//
//  JSONParser.swift
//  Doubt
//
//  Created by Josh Vera on 10/16/15.
//  Copyright © 2015 GitHub. All rights reserved.
//

import Foundation
import Madness
import Prelude

public typealias CofreeJSON = Cofree<JSONLeaf, (SourcePos<String.Index>, Range<String.Index>)>
public typealias JSONParser = Parser<String.CharacterView, CofreeJSON>.Function

// Inlined for performance reasons
let whitespace = oneOf(" \n\r\t")*

// TODO: Parse unicode escape sequence
let escapeChar: StringParser = curry(+) <^> %"\\" <*> ({ String($0) } <^> oneOf("\\\"bfnrt"))
let otherChar: StringParser = { String($0) } <^> noneOf("\"\\")

// Quoted strings parser
// TODO: Improve string parsing
let stringBody: StringParser = { $0.joinWithSeparator("") } <^> many(escapeChar <|> otherChar)
let quoted = %"\"" *> stringBody <* %"\""

typealias MembersParser = Parser<String.CharacterView, [(String, CofreeJSON)]>.Function;

// Parses an array of (String, CofreeJSON) object members
func members(json: JSONParser) -> MembersParser {
	let keyAndKeyTerm: Parser<String.CharacterView, (String, CofreeJSON)>.Function = quoted --> { (pos, range, key) in
		(key, Cofree((pos, range), .Leaf(.String(key))))
	}
	let pairs: Parser<String.CharacterView, (String, CofreeJSON)>.Function = (curry(pair) <^>
		keyAndKeyTerm
		<* whitespace
		<* %":"
		<* whitespace
		<*> json) --> { (pos, range, values) in
			(values.0.0, Cofree((pos, range), .Fixed([values.0.1, values.1])))
		}

	return sepBy(pairs, whitespace <* %"," <* whitespace)
}

public let json: JSONParser = fix { json in
	let string: JSONParser = quoted --> {
		Cofree(($0, $1), .Leaf(.String($2)))
	} <?> "string"

	let array: JSONParser =  %"["
		<* whitespace
		*> sepBy(whitespace *> json, whitespace <* %"," <* whitespace)
		<* whitespace
		<* %"]"
		--> {
			Cofree(($0, $1), .Indexed($2))
		} <?> "array"

	let object: JSONParser = %"{"
		*> whitespace
		*> members(json)
		<* whitespace
		<* %"}"
		--> { (pos, range, values: [(String, CofreeJSON)]) in
			Cofree((pos, range), .Keyed(Dictionary(elements: values)))
		} <?> "object"

	let numberParser: JSONParser = (number --> { pos, range, value in
		Cofree((pos, range), .Leaf(JSONLeaf.Number(value)))
	}) <?> "number"
	
	let null: JSONParser = %"null" --> { pos, range, value in
		return Cofree((pos, range), .Leaf(.Null))
	} <?> "null"
	
	let boolean: JSONParser = %"false" <|> %"true" --> { pos, range, value in
		let boolean = value == "true"
		return Cofree((pos, range), .Leaf(.Boolean(boolean)))
	} <?> "boolean"

	// TODO: This should be JSON = dict <|> array and
	// Value = dict | array | string | number | null | bool
	return (object <|> array <|> string <|> numberParser <|> boolean <|> null) <* whitespace
}