blather 0.4.8 → 0.4.10

data/README.md

@@ -148,6 +148,17 @@ Command line options:
     -h, --help        Show this message
     -v, --version     Show version
 
+## Health warning:
+
+Some parts of Blather will allow you to do stupid things that don't conform to XMPP
+spec. You should exercise caution and read the relevant specifications (indicated in
+the preamble to most relevant classes).
+
+# Contributions
+
+All contributions are welcome, even encouraged. However, contributions must be
+well tested. If you send me a branch name to merge that'll get my attention faster
+than a change set made directly on master.
 
 # Author
 
@@ -155,7 +166,9 @@ Command line options:
 
 ### Contributors
 
-[Nolan Darilek](http://github.com/thewordnerd)
+* [Nolan Darilek](http://github.com/thewordnerd)
+* [Tim Carey-Smith](http://github.com/halorgium)
+* [Ben Langfeld](http://github.com/benlangfeld)
 
 # Copyright
 

data/lib/blather.rb

@@ -4,6 +4,7 @@
   eventmachine
   nokogiri
   digest/md5
+  digest/sha1
   logger
 
   blather/core_ext/active_support
@@ -21,6 +22,7 @@
   blather/stanza
   blather/stanza/iq
   blather/stanza/iq/query
+  blather/stanza/iq/command
   blather/stanza/iq/roster
   blather/stanza/disco
   blather/stanza/disco/disco_info
@@ -46,6 +48,8 @@
   blather/stanza/pubsub_owner/delete
   blather/stanza/pubsub_owner/purge
 
+  blather/stanza/x
+
   blather/stream
   blather/stream/client
   blather/stream/component

data/lib/blather/core_ext/nokogiri.rb

@@ -22,9 +22,11 @@ module XML
     # and namespace designation
     def xpath(*paths)
       paths[0] = paths[0].to_s
+
       if paths.size > 1 && (namespaces = paths.pop).is_a?(Hash)
         paths << namespaces.inject({}) { |h,v| h[v[0].to_s] = v[1]; h }
       end
+
       nokogiri_xpath *paths
     end
     alias_method :find, :xpath

data/lib/blather/stanza/iq/command.rb

@@ -0,0 +1,305 @@
+module Blather
+class Stanza
+class Iq
+
+  # # Command Stanza
+  #
+  # [XEP-0050 Ad-Hoc Commands](http://xmpp.org/extensions/xep-0050.html)
+  #
+  # This is a base class for any command based Iq stanzas. It provides a base set
+  # of methods for working with command stanzas
+  #
+  # @handler :command
+  class Command < Iq
+    VALID_ACTIONS = [:cancel, :execute, :complete, :next, :prev].freeze
+    VALID_STATUS = [:executing, :completed, :canceled].freeze
+    VALID_NOTE_TYPES = [:info, :warn, :error].freeze
+
+    register :command, :command, 'http://jabber.org/protocol/commands'
+
+    # Overrides the parent method to ensure a command node is created
+    #
+    # @param [:get, :set, :result, :error, nil] type the IQ type
+    # @param [String] node the name of the node
+    # @param [:cancel, :execute, :complete, :next, :prev, nil] action the command's action
+    # @return [Command] a new Command stanza
+    def self.new(type = :set, node = nil, action = :execute)
+      new_node = super type
+      new_node.command
+      new_node.node = node
+      new_node.action = action
+      new_node.new_sessionid!
+      new_node
+    end
+
+    # Overrides the parent method to ensure the current command node is destroyed
+    #
+    # @see Blather::Stanza::Iq#inherit
+    def inherit(node)
+      command.remove
+      super
+    end
+
+    # Command node accessor
+    # If a command node exists it will be returned.
+    # Otherwise a new node will be created and returned
+    #
+    # @return [Blather::XMPPNode]
+    def command
+      c = if self.class.registered_ns
+        find_first('command_ns:command', :command_ns => self.class.registered_ns)
+      else
+        find_first('command')
+      end
+
+      unless c
+        (self << (c = XMPPNode.new('command', self.document)))
+        c.namespace = self.class.registered_ns
+      end
+      c
+    end
+
+    # Get the name of the node
+    #
+    # @return [String, nil]
+    def node
+      command[:node]
+    end
+
+    # Set the name of the node
+    #
+    # @param [String, nil] node the new node name
+    def node=(node)
+      command[:node] = node
+    end
+
+    # Get the sessionid of the command
+    #
+    # @return [String, nil]
+    def sessionid
+      command[:sessionid]
+    end
+
+    # Set the sessionid of the command
+    #
+    # @param [String, nil] sessionid the new sessionid
+    def sessionid=(sessionid)
+      command[:sessionid] = Digest::SHA1.hexdigest(sessionid)
+    end
+
+    # Generate a new session ID (SHA-1 hash)
+    def new_sessionid!
+      self.sessionid = "commandsession-"+id
+    end
+
+    # Get the action of the command
+    #
+    # @return [Symbol, nil]
+    def action
+      command.read_attr :action, :to_sym
+    end
+
+    # Check if the command action is :cancel
+    #
+    # @return [true, false]
+    def cancel?
+      self.action == :cancel
+    end
+
+    # Check if the command action is :execute
+    #
+    # @return [true, false]
+    def execute?
+      self.action == :execute
+    end
+
+    # Check if the command action is :complete
+    #
+    # @return [true, false]
+    def complete?
+      self.action == :complete
+    end
+
+    # Check if the command action is :next
+    #
+    # @return [true, false]
+    def next?
+      self.action == :next
+    end
+
+    # Check if the command action is :prev
+    #
+    # @return [true, false]
+    def prev?
+      self.action == :prev
+    end
+
+    # Set the action of the command
+    #
+    # @param [:cancel, :execute, :complete, :next, :prev] action the new action
+    def action=(action)
+      if action && !VALID_ACTIONS.include?(action.to_sym)
+        raise ArgumentError, "Invalid Action (#{action}), use: #{VALID_ACTIONS*' '}"
+      end
+      command[:action] = action
+    end
+
+    # Get the status of the command
+    #
+    # @return [Symbol, nil]
+    def status
+      command.read_attr :status, :to_sym
+    end
+
+    # Check if the command status is :executing
+    #
+    # @return [true, false]
+    def executing?
+      self.status == :executing
+    end
+
+    # Check if the command status is :completed
+    #
+    # @return [true, false]
+    def completed?
+      self.status == :completed
+    end
+
+    # Check if the command status is :canceled
+    #
+    # @return [true, false]
+    def canceled?
+      self.status == :canceled
+    end
+
+    # Set the status of the command
+    #
+    # @param [:executing, :completed, :canceled] status the new status
+    def status=(status)
+      if status && !VALID_STATUS.include?(status.to_sym)
+        raise ArgumentError, "Invalid Action (#{statusn}), use: #{VALID_STATUS*' '}"
+      end
+      command[:status] = status
+    end
+
+    # Command actions accessor
+    # If a command actions element exists it will be returned.
+    # Otherwise a new actions element will be created and returned
+    #
+    # @return [Blather::XMPPNode]
+    def actions
+      a = find_first('actions')
+
+      unless a
+        (self << (a = XMPPNode.new('actions', self.document)))
+      end
+      a
+    end
+
+    # Get the command's allowed actions
+    #
+    # @return [[Symbol]]
+    def allowed_actions
+      a = []
+      a << :execute
+      actions.children.each do |action|
+        a << action.name.to_sym
+      end
+      a
+    end
+
+    # Add allowed actions to the command
+    #
+    # @param [[:prev, :next, :complete]] allowed_actions the new allowed actions
+    def add_allowed_actions(allowed_actions)
+      [allowed_actions].flatten.each do |action|
+        if action && !VALID_ACTIONS.include?(action.to_sym)
+          raise ArgumentError, "Invalid Action (#{action}), use: #{VALID_ACTIONS*' '}"
+        end
+        actions << "<#{action.to_s}/>"
+      end
+    end
+
+    # Remove allowed actions from the command
+    #
+    # @param [[:prev, :next, :complete]] disallowed_actions the allowed actions to remove
+    def remove_allowed_actions(disallowed_actions)
+      [disallowed_actions].flatten.each do |action|
+        actions.remove_children action.to_sym
+      end
+    end
+
+    # Command note accessor
+    # If a command note exists it will be returned.
+    # Otherwise a new note will be created and returned
+    #
+    # @return [Blather::XMPPNode]
+    def note
+      n = find_first('note')
+
+      unless n
+        (self << (n = XMPPNode.new('note', self.document)))
+      end
+      n
+    end
+
+    # Get the note_type of the command
+    #
+    # @return [Symbol, nil]
+    def note_type
+      note.read_attr :type, :to_sym
+    end
+
+    # Check if the command status is :info
+    #
+    # @return [true, false]
+    def info?
+      self.note_type == :info
+    end
+
+    # Check if the command status is :warn
+    #
+    # @return [true, false]
+    def warn?
+      self.status == :warn
+    end
+
+    # Check if the command status is :error
+    #
+    # @return [true, false]
+    def error?
+      self.status == :error
+    end
+
+    # Set the note_type of the command
+    #
+    # @param [:executing, :completed, :canceled] note_type the new note_type
+    def note_type=(note_type)
+      if note_type && !VALID_NOTE_TYPES.include?(note_type.to_sym)
+        raise ArgumentError, "Invalid Action (#{note_type}), use: #{VALID_NOTE_TYPES*' '}"
+      end
+      note[:type] = note_type
+    end
+
+    # Get the text of the command's note
+    def note_text
+      content_from "note"
+    end
+
+    # Set the command's note text
+    #
+    # @param [String] note_text the command's new note text
+    def note_text=(note_text)
+      set_content_for "note", note_text
+    end
+
+    # Returns the command's x:data form child
+    def form
+      X.new command.find_first('//ns:x', :ns => X.registered_ns)
+    end
+
+  end #Command
+
+end #Iq
+end #Stanza
+end

data/lib/blather/stanza/x.rb

@@ -0,0 +1,351 @@
+module Blather
+class Stanza
+  # # X Stanza
+  #
+  # [XEP-0004 Data Forms](http://xmpp.org/extensions/xep-0004.html)
+  #
+  # Data Form node that allows for semi-structured data exchange
+  #
+  # @handler :x
+  class X < XMPPNode
+    register :x, 'jabber:x:data'
+
+    VALID_TYPES = [:cancel, :form, :result, :submit].freeze
+
+    # Create a new X node
+    # @param [:cancel, :form, :result, :submit, nil] type the x:form type
+    # @param [Array<Array, X::Field>, nil] fields a list of fields.
+    # These are passed directly to X::Field.new
+    # @return [X] a new X stanza
+    def self.new(type = nil, fields = [])
+      new_node = super :x
+
+      case type
+      when Nokogiri::XML::Node
+        new_node.inherit type
+      when Hash
+        new_node.type = type[:type]
+        new_node.add_fields([type[:fields]])
+      else
+        new_node.type = type
+        new_node.add_fields([fields])
+      end
+      new_node
+    end
+
+    # The Form's type
+    # @return [Symbol]
+    def type
+      read_attr :type, :to_sym
+    end
+
+    # Set the Form's type
+    # @param [:cancel, :form, :result, :submit] type the new type for the form
+    def type=(type)
+      if type && !VALID_TYPES.include?(type.to_sym)
+        raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}"
+      end
+      write_attr :type, type
+    end
+
+    # List of field objects
+    # @return [Blather::Stanza::X::Field]
+    def fields
+      self.find('ns:field', :ns => self.class.registered_ns).map do |f|
+        Field.new f
+      end
+    end
+
+    # Add an array of fields to form
+    # @param fields the array of fields, passed directly to Field.new
+    def add_fields(fields = [])
+      [fields].flatten.each { |f| self << Field.new(f) }
+    end
+
+    # Check if the x is of type :cancel
+    #
+    # @return [true, false]
+    def cancel?
+      self.type == :cancel
+    end
+
+    # Check if the x is of type :form
+    #
+    # @return [true, false]
+    def form?
+      self.type == :form
+    end
+
+    # Check if the x is of type :result
+    #
+    # @return [true, false]
+    def result?
+      self.type == :result
+    end
+
+    # Check if the x is of type :submit
+    #
+    # @return [true, false]
+    def submit?
+      self.type == :submit
+    end
+
+    # Retrieve the form's instructions
+    #
+    # @return [String]
+    def instructions
+      if i = self.find_first('ns:instructions', :ns => self.class.registered_ns)
+        i.children.inner_text
+      end
+    end
+
+    # Set the form's instructions
+    #
+    # @param [String] instructions the form's instructions
+    def instructions=(instructions)
+      self.remove_children :instructions
+      self << "<instructions>#{instructions}</instructions>"
+    end
+
+    # Retrieve the form's title
+    #
+    # @return [String]
+    def title
+      if t = self.find_first('ns:title', :ns => self.class.registered_ns)
+        t.children.inner_text
+      end
+    end
+
+    # Set the form's title
+    #
+    # @param [String] title the form's title
+    def title=(title)
+      self.remove_children :title
+      self << "<title>#{title}</title>"
+    end
+
+    class Field < XMPPNode
+      VALID_TYPES = [:boolean, :fixed, :hidden, :"jid-multi", :"jid-single", :"list-multi", :"list-single", :"text-multi", :"text-private", :"text-single"].freeze
+
+      # Create a new X Field
+      # @overload new(node)
+      #   Imports the XML::Node to create a Field object
+      #   @param [XML::Node] node the node object to import
+      # @overload new(opts = {})
+      #   Creates a new Field using a hash of options
+      #   @param [Hash] opts a hash of options
+      #   @option opts [:boolean, :fixed, :hidden, :"jid-multi", :"jid-single", :"list-multi", :"list-single", :"text-multi", :"text-private", :"text-single"] :type the type of the field
+      #   @option opts [String] :var the variable for the field
+      #   @option opts [String] :label the label for the field
+      # @overload new(type, var = nil, label = nil)
+      #   Create a new Field by name
+      #   @param [:boolean, :fixed, :hidden, :"jid-multi", :"jid-single", :"list-multi", :"list-single", :"text-multi", :"text-private", :"text-single"] type the type of the field
+      #   @param [String, nil] var the variable for the field
+      #   @param [String, nil] label the label for the field
+      def self.new(type, var = nil, label = nil)
+        new_node = super :field
+
+        case type
+        when Nokogiri::XML::Node
+          new_node.inherit type
+        when Hash
+          new_node.type = type[:type]
+          new_node.var = type[:var]
+          new_node.label = type[:label]
+        else
+          new_node.type = type
+          new_node.var = var
+          new_node.label = label
+        end
+        new_node
+      end
+
+      # The Field's type
+      # @return [String]
+      def type
+        read_attr :type
+      end
+
+      # Set the Field's type
+      # @param [#to_sym] type the new type for the field
+      def type=(type)
+        if type && !VALID_TYPES.include?(type.to_sym)
+          raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}"
+        end
+        write_attr :type, type
+      end
+
+      # The Field's var
+      # @return [String]
+      def var
+        read_attr :var
+      end
+
+      # Set the Field's var
+      # @param [String] var the new var for the field
+      def var=(var)
+        write_attr :var, var
+      end
+
+      # The Field's label
+      # @return [String]
+      def label
+        read_attr :label
+      end
+
+      # Set the Field's label
+      # @param [String] label the new label for the field
+      def label=(label)
+        write_attr :label, label
+      end
+
+      # Get the field's value
+      #
+      # @param [String]
+      def value
+        if v = self.find_first('value')
+          v.children.inner_text
+        end
+      end
+
+      # Set the field's value
+      #
+      # @param [String] value the field's value
+      def value=(value)
+        self.remove_children :value
+        self << "<value>#{value}</value>"
+      end
+
+      # Get the field's description
+      #
+      # @param [String]
+      def desc
+        if d = self.find_first('desc')
+          d.children.inner_text
+        end
+      end
+
+      # Set the field's description
+      #
+      # @param [String] description the field's description
+      def desc=(description)
+        self.remove_children :desc
+        self << "<desc>#{description}</desc>"
+      end
+
+      # Get the field's required flag
+      #
+      # @param [true, false]
+      def required?
+        self.find_first('required') ? true : false
+      end
+
+      # Set the field's required flag
+      #
+      # @param [true, false] required the field's required flag
+      def required!(required = true)
+        if self.find_first('required')
+          if required==false
+            self.remove_children :required
+          end
+        else
+          if required==true
+            self << "<required/>"
+          end
+        end
+      end
+
+      # Extract list of option objects
+      #
+      # @return [Blather::Stanza::X::Field::Option]
+      def options
+        self.find('option').map do |f|
+          Option.new f
+        end
+      end
+
+      # Add an array of options to field
+      # @param options the array of options, passed directly to Option.new
+      def add_options(options = [])
+        [options].flatten.each { |o| self << Option.new(o) }
+      end
+
+      # Compare two Field objects by type, var and label
+      # @param [X::Field] o the Field object to compare against
+      # @return [true, false]
+      def eql?(o)
+        unless o.is_a?(self.class)
+          raise "Cannot compare #{self.class} with #{o.class}"
+        end
+
+        o.type == self.type &&
+        o.var == self.var &&
+        o.label == self.label &&
+        o.desc == self.desc &&
+        o.required? == self.required? &&
+        o.value == self.value
+      end
+      alias_method :==, :eql?
+
+      class Option < XMPPNode
+        # Create a new X Field Option
+        # @overload new(node)
+        #   Imports the XML::Node to create a Field option object
+        #   @param [XML::Node] node the node object to import
+        # @overload new(opts = {})
+        #   Creates a new Field option using a hash of options
+        #   @param [Hash] opts a hash of options
+        #   @option opts [String] :value the value of the field option
+        #   @option opts [String] :label the human readable label for the field option
+        # @overload new(value, label = nil)
+        #   Create a new Field option by name
+        #   @param [String] value the value of the field option
+        #   @param [String, nil] label the human readable label for the field option
+        def self.new(value, label = nil)
+          new_node = super :option
+
+          case value
+          when Nokogiri::XML::Node
+            new_node.inherit value
+          when Hash
+            new_node.value = value[:value]
+            new_node.label = value[:label]
+          else
+            new_node.value = value
+            new_node.label = label
+          end
+          new_node
+        end
+
+        # The Field Option's value
+        # @return [String]
+        def value
+          if v = self.find_first('value')
+            v.children.inner_text
+          end
+        end
+
+        # Set the Field Option's value
+        # @param [String] value the new value for the field option
+        def value=(v)
+          self.remove_children :value
+          self << "<value>#{v}</value>"
+        end
+
+        # The Field Option's label
+        # @return [String]
+        def label
+          read_attr :label
+        end
+
+        # Set the Field Option's label
+        # @param [String] label the new label for the field option
+        def label=(label)
+          write_attr :label, label
+        end
+      end # Option
+    end # Field
+  end # X
+
+end #Stanza
+end

data/spec/blather/stanza/iq/command_spec.rb

@@ -0,0 +1,159 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+def command_xml
+  <<-XML
+  <iq type='result'
+      from='catalog.shakespeare.lit'
+      to='romeo@montague.net/orchard'
+      id='form2'>
+    <command xmlns='http://jabber.org/protocol/commands'
+             node='node1'
+             action='execute'
+             sessionid='dqjiodmqlmakm'>
+      <x xmlns='jabber:x:data' type='form'>
+        <field var='field-name' type='text-single' label='description' />
+      </x>
+    </command>
+  </iq>
+  XML
+end
+
+describe Blather::Stanza::Iq::Command do
+  it 'registers itself' do
+    Blather::XMPPNode.class_from_registration(:command, 'http://jabber.org/protocol/commands').must_equal Blather::Stanza::Iq::Command
+  end
+
+  it 'must be importable' do
+    Blather::XMPPNode.import(parse_stanza(command_xml).root).must_be_instance_of Blather::Stanza::Iq::Command
+  end
+
+  it 'ensures a command node is present on create' do
+    c = Blather::Stanza::Iq::Command.new
+    c.xpath('xmlns:command', :xmlns => Blather::Stanza::Iq::Command.registered_ns).wont_be_empty
+  end
+
+  it 'ensures a command node exists when calling #command' do
+    c = Blather::Stanza::Iq::Command.new
+    c.remove_children :command
+    c.xpath('ns:command', :ns => Blather::Stanza::Iq::Command.registered_ns).must_be_empty
+
+    c.command.wont_be_nil
+    c.xpath('ns:command', :ns => Blather::Stanza::Iq::Command.registered_ns).wont_be_empty
+  end
+
+  Blather::Stanza::Iq::Command::VALID_ACTIONS.each do |valid_action|
+    it "provides a helper (#{valid_action}?) for action #{valid_action}" do
+      Blather::Stanza::Iq::Command.new.must_respond_to :"#{valid_action}?"
+    end
+  end
+
+  Blather::Stanza::Iq::Command::VALID_STATUS.each do |valid_status|
+    it "provides a helper (#{valid_status}?) for status #{valid_status}" do
+      Blather::Stanza::Iq::Command.new.must_respond_to :"#{valid_status}?"
+    end
+  end
+
+  Blather::Stanza::Iq::Command::VALID_NOTE_TYPES.each do |valid_note_type|
+    it "provides a helper (#{valid_note_type}?) for note_type #{valid_note_type}" do
+      Blather::Stanza::Iq::Command.new.must_respond_to :"#{valid_note_type}?"
+    end
+  end
+
+  [:cancel, :execute, :complete, :next, :prev].each do |action|
+    it "action can be set as \"#{action}\"" do
+      c = Blather::Stanza::Iq::Command.new nil, nil, action
+      c.action.must_equal action
+    end
+  end
+
+  [:get, :set, :result, :error].each do |type|
+    it "can be set as \"#{type}\"" do
+      c = Blather::Stanza::Iq::Command.new type
+      c.type.must_equal type
+    end
+  end
+
+  it 'sets type to "result" on reply' do
+    c = Blather::Stanza::Iq::Command.new
+    c.type.must_equal :set
+    reply = c.reply.type.must_equal :result
+  end
+
+  it 'sets type to "result" on reply!' do
+    c = Blather::Stanza::Iq::Command.new
+    c.type.must_equal :set
+    c.reply!
+    c.type.must_equal :result
+  end
+
+  # TODO: Deal with #reply/#reply! better?
+
+  it 'can be registered under a namespace' do
+    class CommandNs < Blather::Stanza::Iq::Command; register :command_ns, nil, 'command:ns'; end
+    Blather::XMPPNode.class_from_registration(:command, 'command:ns').must_equal CommandNs
+    c_ns = CommandNs.new
+    c_ns.xpath('command').must_be_empty
+    c_ns.xpath('ns:command', :ns => 'command:ns').size.must_equal 1
+
+    c_ns.command
+    c_ns.command
+    c_ns.xpath('ns:command', :ns => 'command:ns').size.must_equal 1
+  end
+
+  it 'is constructed properly' do
+    n = Blather::Stanza::Iq::Command.new :set, "node", :execute
+    n.to = 'to@jid.com'
+    n.find("/iq[@to='to@jid.com' and @type='set' and @id='#{n.id}']/ns:command[@node='node' and @action='execute']", :ns => Blather::Stanza::Iq::Command.registered_ns).wont_be_empty
+  end
+
+  it 'has an action attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.action.must_equal :execute
+    n.action = :cancel
+    n.action.must_equal :cancel
+  end
+
+  it 'has a status attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.status.must_equal nil
+    n.status = :executing
+    n.status.must_equal :executing
+  end
+
+  it 'has a sessionid attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.sessionid.wont_be_nil
+    n.sessionid = "somerandomstring"
+    n.sessionid.must_equal Digest::SHA1.hexdigest("somerandomstring")
+  end
+
+  it 'has an allowed_actions attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.allowed_actions.must_equal [:execute]
+    n.add_allowed_actions [:prev, :next]
+    n.allowed_actions.must_equal [:execute, :prev, :next]
+    n.remove_allowed_actions :prev
+    n.allowed_actions.must_equal [:execute, :next]
+  end
+
+  it 'has a note_type attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.note_type.must_equal nil
+    n.note_type = :info
+    n.note_type.must_equal :info
+  end
+
+  it 'has a note_text attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.note_text.must_equal nil
+    n.note_text = "Some text"
+    n.note_text.must_equal "Some text"
+  end
+
+  it 'makes a form child available' do
+    n = Blather::XMPPNode.import(parse_stanza(command_xml).root)
+    n.form.fields.size.must_equal 1
+    n.form.fields.map { |f| f.class }.uniq.must_equal [Blather::Stanza::X::Field]
+    n.form.must_be_instance_of Blather::Stanza::X
+  end
+end

data/spec/blather/stanza/pubsub/retract_spec.rb

@@ -69,7 +69,7 @@ describe Blather::Stanza::PubSub::Retract do
 
   it 'will iterate over each retraction' do
     Blather::XMPPNode.import(parse_stanza(retract_xml).root).each do |i|
-      i.must_include %w[ae890ac52d0df67ed7cfdf51b644e901]
+      i.must_include "ae890ac52d0df67ed7cfdf51b644e901"
     end
   end
 end

data/spec/blather/stanza/x_spec.rb

@@ -0,0 +1,228 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+def x_xml
+  <<-XML
+  <x xmlns='jabber:x:data'
+     type='form'>
+    <title/>
+    <instructions/>
+    <field var='field-name'
+           type='text-single'
+           label='description' />
+    <field var='field-name2'
+           type='text-single'
+           label='description' />
+    <field var='field-name3'
+           type='text-single'
+           label='description' />
+    <field var='field-name'
+           type='{field-type}'
+           label='description'>
+      <desc/>
+      <required/>
+      <value>field-value</value>
+      <option label='option-label'><value>option-value</value></option>
+      <option label='option-label'><value>option-value</value></option>
+    </field>
+  </x>
+  XML
+end
+
+describe Blather::Stanza::X do
+
+  it 'can be created from an XML string' do
+    x = Blather::Stanza::X.new parse_stanza(x_xml).root
+    x.type.must_equal :form
+    x.must_be_instance_of Blather::Stanza::X
+  end
+
+  [:cancel, :form, :result, :submit].each do |type|
+    it "type can be set as \"#{type}\"" do
+      x = Blather::Stanza::X.new type
+      x.type.must_equal type
+    end
+  end
+
+  it 'is constructed properly' do
+    n = Blather::Stanza::X.new :form
+    n.find("/ns:x[@type='form']", :ns => Blather::Stanza::X.registered_ns).wont_be_empty
+  end
+
+  it 'has an action attribute' do
+    n = Blather::Stanza::X.new :form
+    n.type.must_equal :form
+    n.type = :submit
+    n.type.must_equal :submit
+  end
+
+  it 'has a title attribute' do
+    n = Blather::Stanza::X.new :form
+    n.title.must_equal nil
+    n.title = "Hello World!"
+    n.title.must_equal "Hello World!"
+    n.title = "goodbye"
+    n.title.must_equal "goodbye"
+  end
+
+  it 'has an instructions attribute' do
+    n = Blather::Stanza::X.new :form
+    n.instructions.must_equal nil
+    n.instructions = "Please fill in this form"
+    n.instructions.must_equal "Please fill in this form"
+    n.instructions = "goodbye"
+    n.instructions.must_equal "goodbye"
+  end
+
+  it 'inherits a list of fields' do
+    n = Blather::Stanza::Iq::Command.new
+    n.command << parse_stanza(x_xml).root
+    r = Blather::Stanza::X.new.inherit n.form
+    r.fields.size.must_equal 4
+    r.fields.map { |f| f.class }.uniq.must_equal [Blather::Stanza::X::Field]
+  end
+
+  it 'takes a list of hashes for fields' do
+    fields = [
+      {:label => 'label', :type => 'text-single', :var => 'var'},
+      {:label => 'label1', :type => 'text-single', :var => 'var1'},
+    ]
+
+    control = [ Blather::Stanza::X::Field.new(*%w[text-single var label]),
+                Blather::Stanza::X::Field.new(*%w[text-single var1 label1])]
+
+    di = Blather::Stanza::X.new nil, fields
+    di.fields.size.must_equal 2
+    di.fields.each { |f| control.include?(f).must_equal true }
+  end
+
+  it 'takes a list of Field objects as fields' do
+    control = [ Blather::Stanza::X::Field.new(*%w[text-single var label1]),
+                Blather::Stanza::X::Field.new(*%w[text-single var1 label1])]
+
+    di = Blather::Stanza::X.new nil, control
+    di.fields.size.must_equal 2
+    di.fields.each { |f| control.include?(f).must_equal true }
+  end
+
+  it 'takes a mix of hashes and field objects as fields' do
+    fields = [
+      {:label => 'label', :type => 'text-single', :var => 'var'},
+      Blather::Stanza::X::Field.new(*%w[text-single var1 label1]),
+    ]
+
+    control = [ Blather::Stanza::X::Field.new(*%w[text-single var label]),
+                Blather::Stanza::X::Field.new(*%w[text-single var1 label1])]
+
+    di = Blather::Stanza::X.new nil, fields
+    di.fields.size.must_equal 2
+    di.fields.each { |f| control.include?(f).must_equal true }
+  end
+
+  it 'allows adding of fields' do
+    di = Blather::Stanza::X.new nil
+    di.fields.size.must_equal 0
+    di.add_fields [{:label => 'label', :type => 'text-single', :var => 'var'}]
+    di.fields.size.must_equal 1
+    di.add_fields [Blather::Stanza::X::Field.new(*%w[text-single var1 label1])]
+    di.fields.size.must_equal 2
+  end
+
+end
+
+describe Blather::Stanza::X::Field do
+  it 'will auto-inherit nodes' do
+    n = parse_stanza "<field type='text-single' var='music' label='Music from the time of Shakespeare' />"
+    i = Blather::Stanza::X::Field.new n.root
+    i.type.must_equal 'text-single'
+    i.var.must_equal 'music'
+    i.label.must_equal 'Music from the time of Shakespeare'
+  end
+
+  it 'has a type attribute' do
+    n = Blather::Stanza::X::Field.new 'text-single'
+    n.type.must_equal 'text-single'
+    n.type = 'hidden'
+    n.type.must_equal 'hidden'
+  end
+
+  it 'has a var attribute' do
+    n = Blather::Stanza::X::Field.new 'text-single', 'name'
+    n.var.must_equal 'name'
+    n.var = 'email'
+    n.var.must_equal 'email'
+  end
+
+  it 'has a label attribute' do
+    n = Blather::Stanza::X::Field.new 'text-single', 'subject', 'Music from the time of Shakespeare'
+    n.label.must_equal 'Music from the time of Shakespeare'
+    n.label = 'Books by and about Shakespeare'
+    n.label.must_equal 'Books by and about Shakespeare'
+  end
+
+  it 'has a desc attribute' do
+    n = Blather::Stanza::X::Field.new 'text-single', 'subject', 'Music from the time of Shakespeare'
+    n.desc.must_equal nil
+    n.desc = 'Books by and about Shakespeare'
+    n.desc.must_equal 'Books by and about Shakespeare'
+    n.desc = 'goodbye'
+    n.desc.must_equal 'goodbye'
+  end
+
+  it 'has a required? attribute' do
+    n = Blather::Stanza::X::Field.new 'text-single', 'subject', 'Music from the time of Shakespeare'
+    n.required?.must_equal false
+    n.required!
+    n.required?.must_equal true
+    n.required! false
+    n.required?.must_equal false
+  end
+
+  it 'has a value attribute' do
+    n = Blather::Stanza::X::Field.new 'text-single', 'subject', 'Music from the time of Shakespeare'
+    n.value.must_equal nil
+    n.value = 'book1'
+    n.value.must_equal 'book1'
+    n.value = 'book2'
+    n.value.must_equal 'book2'
+  end
+
+  # Option child elements
+  it 'allows adding of options' do
+    di = Blather::Stanza::X::Field.new nil
+    di.options.size.must_equal 0
+    di.add_options [{:label => 'Person', :value => 'person'}]
+    di.options.size.must_equal 1
+    di.add_options [Blather::Stanza::X::Field::Option.new(*%w[person1 Person1])]
+    di.options.size.must_equal 2
+  end
+
+  it 'raises an error when compared against a non X::Field' do
+    a = Blather::Stanza::X::Field.new('hidden', 'secret_message')
+    lambda { a == 'test' }.must_raise RuntimeError
+  end
+
+  it 'can determine equality' do
+    a = Blather::Stanza::X::Field.new('text-single', 'subject')
+    a.must_equal Blather::Stanza::X::Field.new('text-single', 'subject')
+    a.wont_equal Blather::Stanza::X::Field.new('text-single', 'subject1')
+  end
+end
+
+describe Blather::Stanza::X::Field::Option do
+
+  it 'has a value attribute' do
+    n = Blather::Stanza::X::Field::Option.new 'person1', 'Person 1'
+    n.value.must_equal 'person1'
+    n.value = 'book1'
+    n.value.must_equal 'book1'
+  end
+
+  it 'has a label attribute' do
+    n = Blather::Stanza::X::Field::Option.new 'person1', 'Person 1'
+    n.label.must_equal 'Person 1'
+    n.label = 'Book 1'
+    n.label.must_equal 'Book 1'
+    n.label = 'Book 2'
+    n.label.must_equal 'Book 2'
+  end
+end

data/spec/blather/stream/client_spec.rb

@@ -45,7 +45,7 @@ describe Blather::Stream::Client do
 
   it 'attempts to find the SRV record if a host is not provided' do
     dns = mock(:sort! => nil, :empty? => false)
-    dns.expects(:each).yields(mock({
+    dns.expects(:detect).yields(mock({
       :target => 'd',
       :port => 5222
     }))

data/spec/blather/xmpp_node_spec.rb

@@ -135,10 +135,11 @@ describe Blather::XMPPNode do
     c.namespace = 'foo:bar'
     n << c
 
-    n.find(:bar).size.must_equal 2
-    n.remove_child 'bar', 'foo:bar'
     n.find(:bar).size.must_equal 1
-    n.find(:bar).first.namespace.must_be_nil
+    n.find('//xmlns:bar', :xmlns => 'foo:bar').size.must_equal 1
+    n.remove_child '//xmlns:bar', :xmlns => 'foo:bar'
+    n.find(:bar).size.must_equal 1
+    n.find('//xmlns:bar', :xmlns => 'foo:bar').size.must_equal 0
   end
 
   it 'will remove all child elements' do

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: blather
 version: !ruby/object:Gem::Version 
-  version: 0.4.8
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 10
+  version: 0.4.10
 platform: ruby
 authors: 
 - Jeff Smick
@@ -9,29 +15,41 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-17 00:00:00 -08:00
+date: 2010-07-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 12
+        - 6
         version: 0.12.6
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: nokogiri
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        - 0
         version: 1.4.0
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: An XMPP DSL for Ruby written on top of EventMachine and Nokogiri
 email: sprsquish@gmail.com
 executables: []
@@ -69,6 +87,7 @@ files:
 - lib/blather/stanza/disco/disco_info.rb
 - lib/blather/stanza/disco/disco_items.rb
 - lib/blather/stanza/iq.rb
+- lib/blather/stanza/iq/command.rb
 - lib/blather/stanza/iq/query.rb
 - lib/blather/stanza/iq/roster.rb
 - lib/blather/stanza/message.rb
@@ -90,6 +109,7 @@ files:
 - lib/blather/stanza/pubsub_owner.rb
 - lib/blather/stanza/pubsub_owner/delete.rb
 - lib/blather/stanza/pubsub_owner/purge.rb
+- lib/blather/stanza/x.rb
 - lib/blather/stream.rb
 - lib/blather/stream/client.rb
 - lib/blather/stream/component.rb
@@ -102,6 +122,49 @@ files:
 - lib/blather/xmpp_node.rb
 - LICENSE
 - README.md
+- spec/blather/client/client_spec.rb
+- spec/blather/client/dsl/pubsub_spec.rb
+- spec/blather/client/dsl_spec.rb
+- spec/blather/core_ext/nokogiri_spec.rb
+- spec/blather/errors/sasl_error_spec.rb
+- spec/blather/errors/stanza_error_spec.rb
+- spec/blather/errors/stream_error_spec.rb
+- spec/blather/errors_spec.rb
+- spec/blather/jid_spec.rb
+- spec/blather/roster_item_spec.rb
+- spec/blather/roster_spec.rb
+- spec/blather/stanza/discos/disco_info_spec.rb
+- spec/blather/stanza/discos/disco_items_spec.rb
+- spec/blather/stanza/iq/command_spec.rb
+- spec/blather/stanza/iq/query_spec.rb
+- spec/blather/stanza/iq/roster_spec.rb
+- spec/blather/stanza/iq_spec.rb
+- spec/blather/stanza/message_spec.rb
+- spec/blather/stanza/presence/status_spec.rb
+- spec/blather/stanza/presence/subscription_spec.rb
+- spec/blather/stanza/presence_spec.rb
+- spec/blather/stanza/pubsub/affiliations_spec.rb
+- spec/blather/stanza/pubsub/create_spec.rb
+- spec/blather/stanza/pubsub/event_spec.rb
+- spec/blather/stanza/pubsub/items_spec.rb
+- spec/blather/stanza/pubsub/publish_spec.rb
+- spec/blather/stanza/pubsub/retract_spec.rb
+- spec/blather/stanza/pubsub/subscribe_spec.rb
+- spec/blather/stanza/pubsub/subscription_spec.rb
+- spec/blather/stanza/pubsub/subscriptions_spec.rb
+- spec/blather/stanza/pubsub/unsubscribe_spec.rb
+- spec/blather/stanza/pubsub_owner/delete_spec.rb
+- spec/blather/stanza/pubsub_owner/purge_spec.rb
+- spec/blather/stanza/pubsub_owner_spec.rb
+- spec/blather/stanza/pubsub_spec.rb
+- spec/blather/stanza/x_spec.rb
+- spec/blather/stanza_spec.rb
+- spec/blather/stream/client_spec.rb
+- spec/blather/stream/component_spec.rb
+- spec/blather/stream/parser_spec.rb
+- spec/blather/xmpp_node_spec.rb
+- spec/fixtures/pubsub.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/sprsquish/blather
 licenses: []
@@ -112,21 +175,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: squishtech
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Simpler XMPP built for speed
@@ -144,6 +213,7 @@ test_files:
 - spec/blather/roster_spec.rb
 - spec/blather/stanza/discos/disco_info_spec.rb
 - spec/blather/stanza/discos/disco_items_spec.rb
+- spec/blather/stanza/iq/command_spec.rb
 - spec/blather/stanza/iq/query_spec.rb
 - spec/blather/stanza/iq/roster_spec.rb
 - spec/blather/stanza/iq_spec.rb
@@ -165,6 +235,7 @@ test_files:
 - spec/blather/stanza/pubsub_owner/purge_spec.rb
 - spec/blather/stanza/pubsub_owner_spec.rb
 - spec/blather/stanza/pubsub_spec.rb
+- spec/blather/stanza/x_spec.rb
 - spec/blather/stanza_spec.rb
 - spec/blather/stream/client_spec.rb
 - spec/blather/stream/component_spec.rb