xmppify 0.0.12

data/app/assets/javascripts/xmpp/strophejs-plugins/dataforms/src/strophe.x.coffee

@@ -0,0 +1,443 @@
+# Copyright (c) Markus Kohlhase, 2011
+
+# a little helper
+helper =
+
+  fill: (src, target, klass) -> for f in src
+    target.push if f instanceof klass then f else new klass f
+
+  createHtmlFieldCouple: (f) ->
+    div = $ "<div>"
+    id = "Strophe.x.Field-#{ f.type }-#{f.var}"
+    div
+      .append("<label for='#{id}'>#{f.label or ''}</label>")
+      .append( $(f.toHTML()).attr("id", id ) )
+      .append("<br />")
+    div.children()
+
+  getHtmlFields: (html) ->
+    html = $ html
+    [html.find("input")..., html.find("select")..., html.find("textarea")...]
+
+class Form
+
+  @_types: ["form","submit","cancel","result"]
+
+  constructor: (opt) ->
+
+    @fields = []
+    @items = []
+    @reported = []
+
+    if opt
+      @type = opt.type if opt.type in Form._types
+      @title = opt.title
+      @instructions = opt.instructions
+
+      helper.fill = (src, target, klass) -> for f in src
+        target.push if f instanceof klass then f else new klass f
+
+      if opt.fields
+        helper.fill opt.fields, @fields, Field if opt.fields
+      else if opt.items
+        helper.fill opt.items, @items, Item if opt.items
+        for i in @items
+          for f in i.fields
+            @reported.push f.var if not (f.var in @reported)
+
+  type: "form"
+  title: null
+  instructions: null
+
+  toXML: =>
+
+    xml = ($build "x", { xmlns: "jabber:x:data", @type })
+
+    xml.c("title").t(@title.toString()).up() if @title
+    xml.c("instructions").t(@instructions.toString()).up() if @instructions
+
+    if @fields.length > 0
+      for f in @fields
+        xml.cnode(f.toXML()).up()
+
+    else if @items.length > 0
+      xml.c("reported")
+
+      for r in @reported
+        xml.c("field",{var: r}).up()
+      xml.up()
+
+      for i in @items
+        xml.cnode(i.toXML()).up()
+
+    xml.tree()
+
+  toJSON: =>
+    json = {@type}
+    json.title = @title if @title
+    json.instructions = @instructions if @instructions
+
+    if @fields.length > 0
+      json.fields = []
+      for f in @fields
+        json.fields.push f.toJSON()
+    else if @items.length > 0
+      json.items = []
+      json.reported = @reported
+      json.items.push i.toJSON() for i in @items
+
+    json
+
+
+  toHTML: =>
+
+    form = $("<form data-type='#{@type}'>")
+    form.append("<h1>#{@title}</h1>") if @title
+    form.append("<p>#{@instructions}</p>") if @instructions
+
+    if @fields.length > 0
+      (helper.createHtmlFieldCouple f).appendTo form for f in @fields
+
+    else if @items.length > 0
+      ($ i.toHTML()).appendTo form for i in @items
+
+    form[0]
+
+  @fromXML: (xml) ->
+    xml = $ xml
+    f = new Form
+      type: xml.attr "type"
+
+    title = xml.find "title"
+    if title.length is 1
+      f.title = title.text()
+
+    instr = xml.find "instructions"
+    if instr.length is 1
+      f.instructions = instr.text()
+
+    fields = xml.find "field"
+    items = xml.find "item"
+
+    if items.length > 0
+      f.items = ( Item.fromXML i for i in items)
+
+    else if fields.length > 0
+      f.fields = ( Field.fromXML j for j in fields)
+
+    reported = xml.find "reported"
+    if reported.length is 1
+      fields = reported.find "field"
+      f.reported = ( ($ r).attr("var") for r in fields)
+    f
+
+  @fromHTML: (html) ->
+    html = $ html
+
+
+    f = new Form
+      type: html.attr "data-type"
+
+    title = html.find("h1").text()
+    f.title = title if title
+
+    instructions = html.find("p").text()
+    f.instructions = instructions if instructions
+
+    items = html.find "fieldset"
+    fields = helper.getHtmlFields html
+
+    if items.length > 0
+      f.items = ( Item.fromHTML i for i in items)
+
+      for item in f.items
+        for field in item.fields
+          f.reported.push field.var if not (field.var in f.reported)
+
+    else if fields.length > 0
+      f.fields = ( Field.fromHTML j for j in fields )
+
+    f
+
+
+class Field
+
+  @_types: ["boolean","fixed","hidden","jid-multi","jid-single","list-multi",
+    "list-single", "text-multi", "text-private", "text-single"]
+
+  @_multiTypes = ["list-multi", "jid-multi", "text-multi", "hidden"]
+
+  constructor: (opt) ->
+
+    @options = []
+    @values = []
+
+    if opt
+      @type = opt.type.toString() if opt.type in Field._types
+      @desc = opt.desc.toString() if opt.desc
+      @label = opt.label.toString() if opt.label
+      @var = opt.var?.toString() or "_no_var_was_defined_"
+      @required = opt.required is true or opt.required is "true"
+      @addOptions opt.options if opt.options
+      opt.values = [ opt.value ] if opt.value
+      @addValues opt.values if opt.values
+
+  type: "text-single"
+  desc: null
+  label: null
+  var: "_no_var_was_defined_"
+  required: false
+
+  addValue: (val) => @addValues [val]
+
+  addValues: (vals) =>
+    multi = @type in Field._multiTypes
+    if multi or ( not multi and vals.length is 1 )
+      @values = [@values..., (v.toString() for v in vals)...]
+    @
+
+  addOption: (opt) => @addOptions [opt]
+
+  addOptions: (opts) =>
+    if @type is "list-single" or @type is "list-multi"
+      if typeof opts[0] isnt "object"
+        opts =  (new Option { value: o.toString() } for o in opts)
+      helper.fill opts, @options, Option
+    @
+
+  toJSON: =>
+    json = { @type, @var, @required }
+    json.desc = @desc if @desc
+    json.label = @label if @label
+    json.values = @values if @values
+
+    if @options
+      json.options = []
+      for o in @options
+        json.options.push o.toJSON()
+    json
+
+  toXML: =>
+    attrs = {@type, @var}
+    attrs.label = @label if @label
+
+    xml = ($build "field", attrs )
+
+    xml.c("desc").t(@desc).up() if @desc
+    xml.c("required").up() if @required
+
+    if @values
+      for v in @values
+        xml.c("value").t(v.toString()).up()
+
+    if @options
+      for o in @options
+        xml.cnode(o.toXML()).up()
+    xml.tree()
+
+  toHTML: =>
+
+    switch @type.toLowerCase()
+
+
+      when 'list-single', 'list-multi'
+
+        el = ($ "<select>")
+        el.attr 'multiple', 'multiple' if @type is 'list-multi'
+
+        if @options.length > 0
+          for opt in @options when opt
+            o = $ opt.toHTML()
+            for k in @values
+              o.attr 'selected', 'selected' if k.toString() is opt.value.toString()
+            o.appendTo el
+
+      when 'text-multi', 'jid-multi'
+        el = $ "<textarea>"
+        txt = (line for line in @values).join '\n'
+        el.text txt if txt
+
+      when 'text-single', 'boolean','text-private', 'hidden', 'fixed', 'jid-single'
+
+        el = $ "<input>"
+        el.val @values[0] if @values
+
+        switch @type.toLowerCase()
+
+          when 'text-single'
+            el.attr 'type', 'text'
+            el.attr 'placeholder', @desc
+
+          when 'boolean'
+            el.attr 'type', 'checkbox'
+            val = @values[0]?.toString?()
+            el.attr('checked','checked') if val and ( val is "true" or val is "1" )
+
+          when 'text-private'
+            el.attr 'type', 'password'
+
+          when 'hidden'
+            el.attr 'type', 'hidden'
+
+          when 'fixed'
+            el.attr('type','text').attr('readonly','readonly')
+
+          when 'jid-single'
+            el.attr 'type', 'email'
+
+      else
+        el = $ "<input type='text'>"
+
+    el.attr('name', @var )
+    el.attr('required', @required ) if @required
+    el[0]
+
+  @fromXML: (xml) ->
+    xml = $ xml
+    new Field
+      type:  xml.attr "type"
+      var:   xml.attr "var"
+      label: xml.attr "label"
+      desc:  xml.find("desc").text()
+      required: (xml.find("required").length is 1)
+      values: ( ($ v).text() for v in xml.find "value" )
+      options: ( Option.fromXML o for o in xml.find "option" )
+
+  @_htmlElementToFieldType: (el) ->
+
+    el = $ el
+
+    switch el[0].nodeName.toLowerCase()
+
+      when "textarea"
+        type = "text-multi" # or jid-multi
+
+      when "select"
+
+        if el.attr("multiple") is "multiple"
+          type = "list-multi"
+        else
+          type = "list-single"
+
+      when "input"
+        switch el.attr "type"
+          when "checkbox"
+            type = "boolean"
+          when "email"
+            type = "jid-single"
+          when "hidden"
+            type = "hidden"
+          when "password"
+            type = "text-private"
+          when "text"
+            r = el.attr("readonly") is "readonly"
+            if r
+              type = "fixed"
+            else
+              type = "text-single"
+    type
+
+  @fromHTML: (html) ->
+
+    html = $ html
+    type =  Field._htmlElementToFieldType html
+
+    f = new Field
+      type:type
+      var: html.attr "name"
+      required: (html.attr("required") is "required")
+
+    switch type
+      when "list-multi","list-single"
+        f.values = ( ($ el).val() for el in html.find "option:selected" )
+        f.options= ( Option.fromHTML el for el in html.find "option" )
+      when "text-multi","jid-multi"
+        txt = html.text()
+        f.values = txt.split('\n') if txt.trim() isnt ""
+      when 'text-single', 'boolean','text-private', 'hidden', 'fixed', 'jid-single'
+        f.values = [ html.val() ] if html.val().trim() isnt ""
+
+    f
+
+class Option
+
+  constructor: (opt) ->
+    if opt
+      @label = opt.label.toString() if opt.label
+      @value = opt.value.toString() if opt.value
+
+  label: ""
+  value: ""
+
+  toXML: => ($build "option", { label: @label })
+    .c("value")
+    .t(@value.toString())
+    .tree()
+
+  toJSON: => { @label, @value }
+
+  toHTML: => ($ "<option>").attr('value', @value ).text( @label or @value )[0]
+
+  @fromXML: (xml) ->
+    new Option { label: ($ xml).attr("label"), value: ($ xml).text() }
+
+  @fromHTML: (html) ->
+    new Option { value: ($ html).attr("value"), label: ($ html).text() }
+
+class Item
+
+  constructor: (opts) ->
+
+    @fields = []
+    helper.fill opts.fields, @fields, Field if opts?.fields
+
+  toXML: =>
+    xml = $build "item"
+    for f in @fields
+      xml.cnode( f.toXML() ).up()
+    xml.tree()
+
+  toJSON: =>
+    json = {}
+    if @fields
+      json.fields = []
+      for f in @fields
+        json.fields.push f.toJSON()
+    json
+
+  toHTML: =>
+    fieldset = $ "<fieldset>"
+    (helper.createHtmlFieldCouple f).appendTo fieldset for f in @fields
+    fieldset[0]
+
+  @fromXML: (xml) ->
+    xml = $ xml
+    fields = xml.find "field"
+    new Item
+      fields: ( Field.fromXML f for f in fields)
+
+  @fromHTML: (html) ->
+    new Item fields: ( Field.fromHTML f for f in helper.getHtmlFields(html))
+
+Strophe.x =
+  Form: Form
+  Field: Field
+  Option:Option
+  Item:Item
+
+$form = (opt) -> new Strophe.x.Form opt
+$field = (opt) -> new Strophe.x.Field opt
+$opt = (opt) -> new Strophe.x.Option opt
+$item = (opts) -> new Strophe.x.Item opts
+
+Strophe.addConnectionPlugin 'x',
+
+  init : (conn) ->
+    Strophe.addNamespace 'DATA', 'jabber:x:data'
+    conn.disco.addFeature Strophe.NS.DATA if conn.disco
+
+  parseFromResult: (result) ->
+    if result.nodeName.toLowerCase() is "x"
+      Form.fromXML result
+    else
+      Form.fromXML ($ result).find("x")?[0]