listparser.js

// input, output : textareas

/*
TODO:
  Nothing, for now...
  detailed comments actually explaining how it works...
*/

class ShockwaveListParser {
  constructor () {
    this.directorFunctions = {}

    this.directorFunctions.point = function (x, y) {
      return {
        x: x,
        y: y
      }
    }
  }

  parseList (listTxt) {
    var listMin = this.trimWhiteSpace(listTxt)
    return this.parseSegment(listMin)
  }

  trimWhiteSpace (s) {
    var str = s
    var inString = false
    var quoteTotals = 0
    var out = ''
    for (var i = 0; i < str.length; i++) {
      var curr = str.charAt(i)
      if (curr === ' ' || curr === '\n' || curr === '\t') {
        if (!inString) { continue }
      }
      if (curr === '"') {
        inString = !inString
        quoteTotals++
      }
      out += curr
    }
    var test = quoteTotals - ((Math.floor(quoteTotals / 2)) * 2)
    if (test > 0) throw new Error('uneven quotes detected!')
    return out
  }

  parseSegment (seg) {
    var len1 = seg.length
    var s = this.trimOuterBrackets(seg)
    if (!s) return []
    var len2 = s.length
    var hasChildren = (len2 < len1)
    if (hasChildren) {
      var children = this.getChildren(s)
      // console.log('parseSegment', s);
      var isPropList = this.detectProperty(children[0])
      if (isPropList) {
        var out = {}
        this.appendChildren(out, children, true)
        return out
      } else {
        var out = []
        this.appendChildren(out, children, false)
        return out
      }
    } else {
      var isSymbol = this.detectSymbol(s)
      if (isSymbol) {
        return s
      } else {
        var type = this.getType(s)
        switch (type) {
          case 'number' :
            return this.writeNumber(s)
          case 'string' :
            return this.writeString(s)
          case 'function' :
            return this.writeFunction(s)
        }
      }
    }
  }

  getChildren (s) {
    var section = s
    var limit = section.length - 1
    var out = []
    var inString = false
    var inFunction = false
    var pending = ''
    var nestLevel = 0

    for (var i = 0; i < section.length; i++) {
      var curr = section.charAt(i)

      if (curr === '[') { nestLevel++ }

      if (curr === ']') { nestLevel-- }

      if (curr === '"') { inString = !inString }

      if (curr === '(' || curr === ')') { inFunction = !inFunction }

      if (curr === ',' && nestLevel === 0 && !inString && !inFunction) {
        out.push(pending)
        pending = ''
        continue
      }

      pending += curr

      if (i === limit) { out.push(pending) }
    }

    return out
  }

  detectProperty (s) {
    var suspect = s
    var out = false
    var char = suspect.charAt(0)
    if (char === '#' || (!isNaN(parseFloat(char)) && isFinite(char))) {
      for (var i = 1; i < suspect.length; i++) {
        var curr = suspect.charAt(i)
        if (curr === ':') {
          out = true
          break
        }
        if (curr === '[' || curr === '#' || curr === ']' || curr === ',') {
          throw new Error('the value : ' + s + 'does not seem to be a valid data type!', 'detectProperty')
        }
      }
    }
    return out
  }

  appendChildren (obj, children, isPropList) {
    for (var i = 0; i < children.length; i++) {
      var curr = children[i]
      if (isPropList) {
        var ID = this.getPropertyName(curr)
        var data = this.getPropertyValue(curr)
        var data2 = this.parseSegment(data)
        obj[ID] = data2
      } else {
        var data = this.parseSegment(curr)
        obj.push(data)
      }
    }
  }

  trimOuterBrackets (dat, checkComplex) {
    var d = dat
    var out = d
    var bracketPairs = []
    var currPair = -1
    var hasFailed = false // Can this be removed?
    for (var i = 0; i < d.length; i++) {
      var currChar = d.charAt(i)
      if (currChar === '[') {
        var ID = bracketPairs.length
        bracketPairs.push({s: i, e: null, p: currPair})
        currPair = ID
      }
      if (currChar === ']') {
        if (currPair === -1) {
          throw new Error('INCORRECTLY NESTED BRACKETS DETECTED, ABORTING!')
        }
        var pair = bracketPairs[currPair]
        currPair = pair.p
        pair.e = i
      }
    }
    if (!hasFailed) {
      var lim = d.length - 1
      if (checkComplex) {
        out = {isComplex: false}
      }
      for (var i = 0; i < bracketPairs.length; i++) {
        var test = bracketPairs[i]
        if (test.s === 0 && test.e === lim) {
          if (checkComplex) {
            out.isComplex = true
            break
          } else {
            out = d.slice(1)
            out = out.slice(0, -1)
            break
          }
        }
      }
    }
    bracketPairs = null
    return out
  }

  detectSymbol (s) {
    var suspect = s
    var out = false
    if (suspect.charAt(0) === '#') {
      out = true
      for (var i = 1; i < suspect.length; i++) {
        var curr = suspect.charAt(i)
        if (curr === ':') {
          out = false
          break
        }
        if (curr === '[' || curr === '#' || curr === ']' || curr === ',') {
          throw new Error('the value : ' + s + 'does not seem to be a valid data type!', 'detectSymbol')
        }
      }
    }
    // console.log("detected symbol : " + out);
    return out
  }

  getType (s) {
    var suspect = s
    if (suspect.charAt(0) === '"') { return 'string' }
    if (!isNaN(Number(s))) { return 'number' }
    if (suspect.indexOf('(') !== -1 && suspect.indexOf(')') !== -1) { return 'function' }
  }

  writeNumber (s) {
    return Number(s)
  }

  writeString (s) {
    var out = s.slice(1)
    out = out.slice(0, -1)
    return String(out)
  }

  writeFunction (s) {
    // method of returning function, eval kinda works i guess?
    // var out = s;
    var out = eval('this.directorFunctions.' + s)
    return out
  }

  getPropertyName (p) {
    var out = ''
    for (var i = 0; i < p.length; i++) {
      var curr = p.charAt(i)
      if (curr === '#') { continue }
      if (curr === ':') { break }
      out += curr
    }
    if (out === '') {
      throw new Error('invalid property name detected!')
    }
    return out
  }

  getPropertyValue (p) {
    var out = ''
    var prop = p
    // console.log("parsing property: " + prop);
    for (var i = 0; i < prop.length; i++) {
      var curr = prop.charAt(i)
      if (curr === ':') {
        out = prop.slice(i + 1)
        break
      }
    }
    // console.log("retrieved property value: " + out);
    return out
  }
}

if (typeof exports !== 'undefined') { exports.ShockwaveListParser = ShockwaveListParser }