cancer 0.1.0.a1

data/lib/cancer/xeps/xep_0004_x_data.rb

@@ -0,0 +1,692 @@
+
+module Cancer
+  # Data Forms
+  # http://xmpp.org/extensions/xep-0004.html
+  module XEP_0004
+    include Cancer::XEP
+    
+    dependency 'core'
+    
+    NS  = 'jabber:x:data'
+    
+    def self.enhance_stream(stream)
+      Cancer::Stream.extend Cancer::XEP_0004::SingletonStreamHelper
+      stream.extend_stream do
+        include Cancer::XEP_0004::StreamHelper
+      end
+      stream.extend_builder do
+        include Cancer::XEP_0004::BuilderHelper
+      end
+    end
+    
+    module StreamHelper
+      
+      def define_form(name, &proc)
+        self.defined_forms[name.to_s] = FormDefinition.new(&proc)
+      end
+      
+      def form(name)
+        self.defined_forms[name.to_s]
+      end
+      
+      def defined_forms
+        @defined_forms ||= self.class.defined_forms.dup
+      end
+      
+    end
+    
+    module SingletonStreamHelper
+      
+      def define_form(name, &proc)
+        self.defined_forms[name.to_s] = FormDefinition.new(&proc)
+      end
+      
+      def defined_forms
+        @defined_forms ||= {}
+      end
+      
+    end
+    
+    module BuilderHelper
+      
+      def x(form=nil, options={}, &proc)
+        options, form = form, nil if Hash === form
+        form ||= Form.new(FormDefinition.new(&proc), options[:type])
+        form.build(self, options)
+      end
+      
+    end
+    
+    module HasFieldValues
+      
+      def [](var)
+        @values[var.to_sym]
+      end
+      
+      def []=(var, value)
+        set_value(var, value)
+      end
+      
+      def set_value(var, value, validate=true)
+        @values[var.to_sym] = value
+      end
+      
+      def each(&block)
+        @values.each(&block)
+      end
+      
+      def delete(var)
+        @values.delete(var.to_sym)
+      end
+      
+      def value?(var)
+        @values.key?(var.to_sym)
+      end
+      
+    end
+    
+    module HasDefinition
+      
+      def field(value)
+        @definition.field(value)
+      end
+      
+    end
+    
+    module HasFieldDefinitions
+      
+      def define(var)
+        field = FieldDefinition.new(var)
+        yield field
+        add_field field
+        field
+      end
+      
+      def field(var)
+        @fields_by_name[var.to_sym]
+      end
+      
+      def add_field(field)
+        @fields_by_name[field.var] = field unless field.type == :fixed
+        @fields << field
+        field
+      end
+      
+      def field?(var)
+        @fields_by_name.key?(var.to_sym)
+      end
+      
+      def each_field(&block)
+        @fields.each(&block)
+      end
+      
+      def delete_field(var)
+        field = @fields_by_name[var.to_sym] if var.repond_to?(:to_sym)
+        @fields.delete(field)
+        @fields_by_name.delete(field.var)
+        field
+      end
+      
+    end
+    
+    class Form
+      
+      include HasDefinition
+      include HasFieldValues
+      
+      attr_reader :definition, :type
+      
+      def items
+        @items ||= []
+      end
+      
+      def self.load(xml, definition=nil)
+        definition ||= FormDefinition.load(xml)
+        form = new(definition, (xml[:type] || :form).to_sym)
+        
+        xml.xpath('x:field', 'x' => NS).each do |x|
+          next if x[:type] == 'fixed'
+          
+          field_definition = definition.field(x[:var])
+          form.set_value(x[:var], field_definition.load(x), false)
+        end
+        
+        xml.xpath('x:item', 'x' => NS).each do |x|
+          form.items << Item.load(x, definition.reported)
+        end
+        
+        form
+      end
+      
+      def initialize(definition, type = :form)
+        @definition, @type = definition, type
+        @values = {}
+      end
+      
+      def to_xml(options={})
+        Nokogiri::XML::Builder.new do |builder|
+          build(builder, options)
+        end.doc.root.to_s
+      end
+      
+      def build(builder, options={})
+        options[:values] = self
+        options[:rows] = @items
+        options[:type] ||= @type
+        self.definition.build(builder, options)
+      end
+      
+      def valid?
+        self.definition.each_field do |field|
+          unless (field.var and field.valid?(self[field.var]))
+            return false
+          end
+        end
+        self.items.each { |item| return false unless item.valid? }
+        return true
+      end
+      
+    end
+    
+    class Item
+      
+      include HasDefinition
+      include HasFieldValues
+      
+      attr_reader :definition
+      
+      def self.load(xml, definition)
+        item = new(definition)
+        
+        xml.xpath('x:field', 'x' => NS).each do |x|
+          next if x[:type] == 'fixed'
+          
+          field_definition = definition.field(x[:var])
+          item.set_value(x[:var], field_definition.load(x), false)
+        end
+        
+        item
+      end
+      
+      def initialize(definition)
+        @definition = definition
+        @values = {}
+      end
+      
+      def build(builder, options={})
+        builder.item do
+          self.definition.each_field do |f|
+            f.build(builder, options.merge(:values => @values, :in_item => true))
+          end
+        end
+      end
+      
+      def valid?
+        self.definition.each_field do |field|
+          unless (field.var and field.valid?(self[field.var]))
+            return false
+          end
+        end
+        return true
+      end
+      
+    end
+    
+    class FormDefinition
+      
+      include HasFieldDefinitions
+      
+      attr_accessor :title
+      attr_reader :instructions
+      
+      def self.load(xml)
+        new do |d|
+          
+          xml.xpath('x:reported', 'x' => NS).each do |x|
+            d.add_reported Reported.load(x)
+            break
+          end
+          
+          xml.xpath('x:title', 'x' => NS).each do |x|
+            d.title = x.text.to_s
+            break
+          end
+          
+          xml.xpath('x:instructions', 'x' => NS).each do |x|
+            d.instructions << x.text.to_s
+          end
+          
+          xml.xpath('x:field', 'x' => NS).each do |x|
+            d.add_field FieldDefinition.load(x)
+          end
+          
+        end
+      end
+      
+      def initialize
+        @fields = []
+        @fields_by_name = {}
+        @instructions = []
+        yield(self) if block_given?
+      end
+      
+      def reported(&proc)
+        @reported ||= Reported.new(&proc)
+      end
+      
+      def load(xml)
+        Form.load(xml, self)
+      end
+      
+      def add_reported(reported)
+        @reported = reported
+      end
+      
+      def inspect
+        "(form fields:#{@fields.inspect})"
+      end
+      
+      def to_xml(options={})
+        Nokogiri::XML::Builder.new do |builder|
+          build(builder, options)
+        end.doc.root.to_s
+      end
+      
+      def build(builder, options={})
+        builder.x_(:type => (options[:type] || :form), :xmlns => NS) do
+          if options[:verbose]
+            builder.title(title) if title
+            instructions.each do |instruction|
+              builder.instructions(instruction)
+            end
+          end
+          
+          self.each_field do |f|
+            f.build(builder, options)
+          end
+          
+          @reported.build(builder, options.merge(:values => nil)) if @reported
+          
+          if options[:rows]
+            options[:rows].each do |r|
+              r.build(builder, options)
+            end
+          end
+          
+        end
+      end
+      
+    end
+    
+    class Reported
+      
+      include HasFieldDefinitions
+      
+      def self.load(xml)
+        new do |d|
+          
+          xml.xpath('x:field', 'x' => NS).each do |x|
+            d.add_field FieldDefinition.load(x)
+          end
+          
+        end
+      end
+      
+      def initialize
+        @fields = []
+        @fields_by_name = {}
+        yield(self) if block_given?
+      end
+      
+      def build(builder, options={})
+        builder.reported do
+          self.each_field do |field|
+            field.build(builder, options)
+          end
+        end
+      end
+      
+    end
+    
+    class FieldDefinition
+      
+      attr_accessor :var, :type, :label, :description, :required, :options, :value
+      
+      def self.load(xml)
+        new(xml[:var]) do |d|
+          
+          d.type        = (xml[:type] || 'text-single').to_sym
+          d.label       = xml[:label].to_s if xml[:label]
+          d.required    = !xml.xpath('x:required', 'x' => NS).empty?
+          
+          if d.type == :fixed
+            d.value = xml.xpath('x:value/text()', 'x' => NS).to_s
+          end
+          
+          d.description = xml.xpath('x:desc/text()', 'x' => NS).to_s
+          d.description = nil if d.description and d.description.empty?
+          
+          xml.xpath('x:option', 'x' => NS).each do |x|
+            d.add_option Option.load(x)
+          end
+          
+        end
+      end
+      
+      def initialize(var)
+        @var     = var.to_sym if var
+        @options = {}
+        @option_values = []
+        @type    = :'text-single'
+        @value   = nil
+        yield(self) if block_given?
+      end
+      
+      def add_option(option, label=nil)
+        option = Option.new(option, label) unless Option === option
+        @options[option.value] = option
+        @option_values << option.value
+        option
+      end
+      
+      def option_values
+        @option_values
+      end
+      
+      def load(xml)
+        case self.type
+        when :'boolean'      then load_boolean(xml)
+        when :'fixed'        then load_fixed(xml)
+        when :'hidden'       then load_hidden(xml)
+        when :'jid-multi'    then load_jid_multi(xml)
+        when :'jid-single'   then load_jid_single(xml)
+        when :'list-multi'   then load_list_multi(xml)
+        when :'list-single'  then load_list_single(xml)
+        when :'text-multi'   then load_text_multi(xml)
+        when :'text-private' then load_text_private(xml)
+        when :'text-single'  then load_text_single(xml)
+        end
+      end
+      
+      def valid?(value)
+        case self.type
+        when :'boolean'      then valid_boolean(value)
+        when :'fixed'        then valid_fixed(value)
+        when :'hidden'       then valid_hidden(value)
+        when :'jid-multi'    then valid_jid_multi(value)
+        when :'jid-single'   then valid_jid_single(value)
+        when :'list-multi'   then valid_list_multi(value)
+        when :'list-single'  then valid_list_single(value)
+        when :'text-multi'   then valid_text_multi(value)
+        when :'text-private' then valid_text_private(value)
+        when :'text-single'  then valid_text_single(value)
+        end
+      end
+      
+      def inspect
+        "(field: #{var} type:#{type} options:#{options.inspect} required:#{required.inspect})"
+      end
+      
+      def build(builder, options={})
+        attributes = {}
+        attributes[:var]   = var   if var
+        unless options[:in_item]
+          attributes[:type]  = type  if type != :'text-single'
+          attributes[:label] = label if label and options[:verbose]
+        end
+        builder.field(attributes) do
+          if options[:verbose] and !options[:in_item]
+            builder.required          if required
+            builder.desc(description) if description
+            self.option_values.each do |key|
+              option = self.options[key]
+              option.build(builder, options)
+            end
+          end
+          if options[:values]
+            build_value(builder, @value, options) if @value
+            if self.type != :fixed
+              value = options[:values][self.var] if self.var
+              build_value(builder, value, options)
+            end
+          end
+        end
+      end
+      
+      def remove_options!
+        @options = {}
+        @option_values = []
+      end
+      
+    private
+      
+      def build_value(builder, value, options={})
+        case self.type
+        when :'boolean'      then build_boolean(builder, value, options)
+        when :'fixed'        then build_fixed(builder, value, options)
+        when :'hidden'       then build_hidden(builder, value, options)
+        when :'jid-multi'    then build_jid_multi(builder, value, options)
+        when :'jid-single'   then build_jid_single(builder, value, options)
+        when :'list-multi'   then build_list_multi(builder, value, options)
+        when :'list-single'  then build_list_single(builder, value, options)
+        when :'text-multi'   then build_text_multi(builder, value, options)
+        when :'text-private' then build_text_private(builder, value, options)
+        when :'text-single'  then build_text_single(builder, value, options)
+        end
+      end
+      
+      def load_boolean(xml)
+        %w( true 1 ).include? load_first_value(xml)
+      end
+      
+      ## boolean
+      
+      def build_boolean(builder, value, options={})
+        if value
+          builder.value('true')
+        else
+          builder.value('false')
+        end
+      end
+      
+      def valid_boolean(value)
+        true
+      end
+      
+      ## fixed
+      
+      def load_fixed(xml)
+        nil
+      end
+      
+      def build_fixed(builder, value, options={})
+        builder.value(value)
+      end
+      
+      def valid_fixed(value)
+        true
+      end
+      
+      ## hidden
+      
+      def load_hidden(xml)
+        load_first_value(xml)
+      end
+      
+      def build_hidden(builder, value, options={})
+        builder.value(value.to_s) if value
+      end
+      
+      def valid_hidden(value)
+        value.respond_to?(:to_s) and (required ? value : true)
+      end
+      
+      ## jid-multi
+      
+      def load_jid_multi(xml)
+        load_all_values(xml).collect { |v| v.to_jid }
+      end
+      
+      def build_jid_multi(builder, values, options={})
+        values.each do |value|
+          builder.value(value.to_s)
+        end
+      end
+      
+      def valid_jid_multi(values)
+        valid_multi(values) do |value|
+          valid_jid_single(value)
+        end
+      end
+      
+      ## jid-single
+      
+      def load_jid_single(xml)
+        value = load_first_value(xml)
+        value = value.to_jid if value
+        value
+      end
+      
+      def build_jid_single(builder, value, options={})
+        builder.value(value.to_s) if value
+      end
+      
+      def valid_jid_single(value)
+        value.respond_to?(:to_jid) and (required ? value : true) and (!!value.to_jid rescue false)
+      end
+      
+      ## list-multi
+      
+      def load_list_multi(xml)
+        option_values = options.keys
+        load_all_values(xml) & option_values
+      end
+      
+      def build_list_multi(builder, values, options={})
+        values.each do |value|
+          builder.value(value)
+        end
+      end
+      
+      def valid_list_multi(values)
+        valid_multi(values) do |value|
+          valid_list_single(value)
+        end
+      end
+      
+      ## list-single
+      
+      def load_list_single(xml)
+        value = load_first_value(xml)
+        options.key?(value) ? value : nil
+      end
+      
+      def build_list_single(builder, value, options={})
+        builder.value(value) if value
+      end
+      
+      def valid_list_single(value)
+        value.respond_to?(:to_s) and (required ? value : true) and (value ? options.keys.include?(value.to_s) : true)
+      end
+      
+      ## text-multi
+      
+      def load_text_multi(xml)
+        load_all_values(xml)
+      end
+      
+      def build_text_multi(builder, values, options={})
+        values.each do |value|
+          builder.value(value)
+        end
+      end
+      
+      def valid_text_multi(values)
+        valid_multi(values) do |value|
+          valid_text_single(value)
+        end
+      end
+      
+      ## text-private
+      
+      def load_text_private(xml)
+        load_first_value(xml)
+      end
+      
+      def build_text_private(builder, value, options={})
+        builder.value(value) if value
+      end
+      
+      def valid_text_private(value)
+        value.respond_to?(:to_s) and (required ? value : true)
+      end
+      
+      ## text-single
+      
+      def load_text_single(xml)
+        load_first_value(xml)
+      end
+      
+      def build_text_single(builder, value, options={})
+        builder.value(value) if value
+      end
+      
+      def valid_text_single(value)
+        value.respond_to?(:to_s) and (required ? value : true)
+      end
+      
+      
+      def load_all_values(xml)
+        xml.xpath('x:value/text()', 'x' => NS).to_a.collect { |t| t.to_s }
+      end
+      
+      def load_first_value(xml)
+        v = xml.xpath('x:value/text()', 'x' => NS).first
+        v ? v.to_s : v
+      end
+      
+      def valid_multi(values, &proc)
+        (required ? values : true) and (values ? values.respond_to?(:to_a) : true) and (values ? values.to_a.all?(&proc) : true)
+      end
+      
+    end
+    
+    class Option
+      
+      attr_accessor :label, :value
+      
+      def self.load(xml)
+        new(nil) do |d|
+          
+          d.label = xml[:label].to_s if xml[:label]
+          d.value = xml.xpath('x:value/text()', 'x' => NS).to_s
+          
+        end
+      end
+      
+      def initialize(value, label=nil)
+        @value, @label = value, label
+        yield(self) if block_given?
+      end
+      
+      def inspect
+        if label
+          "(option: #{value.inspect} with label #{label.inspect})"
+        else
+          "(option: #{value.inspect})"
+        end
+      end
+      
+      def build(builder, options={})
+        if options[:verbose]
+          builder.option(label ? { :label => label} : {}) do
+            builder.value(value)
+          end
+        end
+      end
+      
+    end
+    
+    
+  end
+end