#g.get_context(c).add((s,p,o)) # kind of works with broken rdflib nquad serializer code; you need this for json_ld serialize to work :(

        g.store.add((s,p,o), c) # no effect on nquad output

    return g

def graphFromNQuad(text):

    g1 = ConjunctiveGraph()

    g1.parse(data=text, format='nquads')

    return g1

from rdflib.plugins.serializers.nt import _quoteLiteral

def serializeQuad(g):

    """

Polymer

  is: "light9-effects"

  properties: 

    graph: {type: Object}

    effectClasses: { type: Array }

  ready: ->

  getClasses: ->

    U = (x) => @graph.Uri(x)

    @effectClasses = _.sortBy(@graph.subjects(U('rdf:type'), U(':Effect')))

Polymer

    @handlers = new Handler(null) # tree of all known Handlers (at least those with non-empty patterns). Top node is not a handler.

    @handlerStack = [@handlers] # currently running

  runHandler: (func, label) ->

    # what if we have this func already? duplicate is safe?

    h = new Handler(func, label)

    @handlerStack[@handlerStack.length - 1].innerHandlers.push(h)

    console.time("handler #{label}")

    @_rerunHandler(h, null)

    console.timeEnd("handler #{label}")

    # prefixes can be used in Uri(curie) calls.

    @_watchers = new GraphWatchers() # old

    @_autoDeps = new AutoDependencies() # replaces GraphWatchers

    @clearGraph()

    if @patchSenderUrl

                                 @_applyPatch.bind(@), @setStatus)

    # just deletes the statements; watchers are unaffected.

    if @graph?

      @_applyPatch({addQuads: [], delQuads: @graph.find()})

    # if we had a Store already, this lets N3.Store free all its indices/etc

    @graph = N3.Store()

    @_addPrefixes(@prefixes)

    @cachedFloatValues = new Map();

  _addPrefixes: (prefixes) ->

    @graph.addPrefixes(prefixes)

  Uri: (curie) ->

    N3.Util.expandPrefixedName(curie, @graph._prefixes)

  quads: () -> # for debugging

    [q.subject, q.predicate, q.object, q.graph] for q in @graph.find()

  applyAndSendPatch: (patch) ->

    if !Array.isArray(patch.addQuads) || !Array.isArray(patch.delQuads)

      throw new Error("corrupt patch: #{patch}")

    @_applyPatch(patch)

    @_client.sendPatch(patch) if @_client

  _applyPatch: (patch) ->

    # In most cases you want applyAndSendPatch.

    # 

    patch = {addQuads: addQuads, delQuads: []}

    log('save', patch)

    @graph.applyAndSendPatch(patch)

    @newEffectName = ''

  onGraph: ->

  resendAll: ->

    for llc in @getElementsByTagName("light9-live-control")

      llc.resend()

  clearAll: ->

    for llc in @getElementsByTagName("light9-live-control")

      llc.clear()

                    cb()

  async.parallel([parseAdds, parseDels], ((err) => cb(patch)))

class window.RdfDbClient

  # Send and receive patches from rdfdb

    @_patchesToSend = []

    @_lastPingMs = -1

    @_patchesReceived = 0

    @_patchesSent = 0

    @_reconnectionTimeout = null

      #{@_patchesReceived} recv;

      #{@_patchesSent} sent;

      #{@_patchesToSend.length} pending;

      #{ping}ms")

  sendPatch: (patch) ->

    @_patchesToSend.push(patch)

    @_updateStatus()

    @_continueSending()           

  _newConnection: ->

    wsOrWss = window.location.protocol.replace('http', 'ws')

    fullUrl = wsOrWss + '//' + window.location.host + @patchSenderUrl

    @ws.close() if @ws?

    @ws = new WebSocket(fullUrl)

    @ws.onopen = =>

      @_updateStatus()

      @_pingLoop()

    @ws.onerror = (e) =>

      @ws.onclose()

    @ws.onclose = =>

      @_updateStatus()

      clearTimeout(@_reconnectionTimeout) if @_reconnectionTimeout?

      @_reconnectionTimeout = setTimeout(@_newConnection.bind(@), 1000)

    @ws.onmessage = @_onMessage.bind(@)

    # we could call this less often and coalesce patches together to optimize

    # the dragging cases.

    sendOne = (patch, cb) =>

        toJsonPatch(patch, (json) =>

          @ws.send(json)

          @_patchesSent++

          @_updateStatus()

          cb(null)

      )

    graph: { type: Object, notify: true }

    selection: { type: Object, notify: true }

    dia: { type: Object, notify: true }

    song: { type: String, notify: true }

    zoomInX: { type: Object, notify: true }

    rows: { value: [0...ROW_COUNT] }

    zoomFlattened: { type: Object, notify: true }

  onZoom: ->

    updateZoomFlattened = ->

      log('updateZoomFlattened')

      @zoomFlattened = ko.toJS(@zoom)

    ko.computed(updateZoomFlattened.bind(@))

        quad(newCurve, U(':attr'), U(':strength'))

      ]        

    pointQuads = []

    desiredWidthX = @offsetWidth * .3

    desiredWidthT = @zoomInX.invert(desiredWidthX) - @zoomInX.invert(0)

    for i in [0...4]

      pt = points[i]

      pointQuads.push(quad(newCurve, U(':point'), pt))

      pointQuads.push(quad(pt, U(':time'), @graph.LiteralRoundedFloat(i/3 * desiredWidthT)))

      pointQuads.push(quad(pt, U(':value'), @graph.LiteralRoundedFloat(i == 1 or i == 2)))

    if @colorScale == @colorScaleFromGraph

      return

    @editAttr(@song, @uri, U(':colorScale'), @graph.Literal(@colorScale))

  editAttr: (song, note, attr, value) ->

    U = (x) => @graph.Uri(x)

    quad = (s, p, o) => {subject: s, predicate: p, object: o, graph: song}

    existingColorScaleSetting = null

    for setting in @graph.objects(note, U(':setting'))

      ea = @graph.uriValue(setting, U(':effectAttr'))

      if ea == attr

        quad(setting, U(':effectAttr'), attr)

        quad(setting, U(':value'), value)

        ]}

      @graph.applyAndSendPatch(patch)

  addHandler: ->

  update: ->

    #console.time('attrs update')

    U = (x) => @graph.Uri(x)

    @effect = @graph.uriValue(@uri, U(':effectClass'))

    @effectLabel = @graph.stringValue(@effect, U('rdfs:label')) or (@effect.replace(/.*\//, ''))