jubjub 0.0.5 → 0.0.6

data/lib/jubjub/muc/collection.rb

@@ -0,0 +1,55 @@
+# Uses proxy pattern for syntax sugar
+# and delaying expensive operations until
+# required
+class Jubjub::Muc::Collection
+   
+  attr_reader :jid
+   
+  def initialize(jid, connection)
+    @jid = Jubjub::Jid.new(jid)
+    @connection = connection
+  end
+  
+  def create(node, nick = nil, &block)
+    full_jid = Jubjub::Jid.new node, @jid.domain, nick || @connection.jid.node
+
+    if block_given?
+      # Reserved room
+      config = @connection.muc.configuration full_jid
+      yield config
+      @connection.muc.create full_jid, config
+    else
+      # Instant room
+      result = @connection.muc.create full_jid
+    end
+    
+  end
+  
+  def [](jid_node_num)
+    case jid_node_num
+    when Fixnum
+      list[jid_node_num]
+    when Jubjub::Jid
+      list.find{|m| m.jid == jid_node_num } || Jubjub::Muc.new( jid_node_num, nil, @connection )
+    else
+      j = Jubjub::Jid.new jid_node_num, jid.domain
+      list.find{|m| m.jid == j } || Jubjub::Muc.new( j, nil, @connection )
+    end
+  end
+  
+  # Hint that methods are actually applied to list using method_missing
+  def inspect
+    list.inspect
+  end
+  
+private
+
+  def method_missing(name, *args, &block)
+    list.send(name, *args, &block)
+  end
+    
+  def list
+    @list ||= @connection.muc.list @jid
+  end
+  
+end

data/lib/jubjub/muc/configuration.rb

@@ -0,0 +1,5 @@
+require 'jubjub/data_form'
+
+class Jubjub::Muc::Configuration < Jubjub::DataForm
+  
+end

data/lib/jubjub/muc/muc.rb

@@ -0,0 +1,37 @@
+module Jubjub
+  class Muc
+    
+    attr_reader :jid, :name
+    
+    def initialize(jid, name = nil, connection = nil)
+      @jid = Jubjub::Jid.new(jid)
+      @name = name
+      @connection = connection
+    end 
+    
+    def exit(nick = nil)
+      full_jid = Jubjub::Jid.new @jid.node, @jid.domain, nick || @connection.jid.node
+      
+      @connection.muc.exit(full_jid)
+      self
+    end
+    
+    def destroy
+      @connection.muc.destroy(@jid)
+    end
+    
+    # Hide the connection details and show jid as string for compactness
+    def inspect
+      obj_id = "%x" % (object_id << 1)
+      "#<#{self.class}:0x#{obj_id} @jid=\"#{@jid}\" @name=#{@name.inspect}>"
+    end
+    
+    def ==(other)
+      other.is_a?( self.class ) &&
+      other.jid     == self.jid &&
+      other.name    == self.name
+    end
+    
+  end 
+
+end

data/lib/jubjub/pubsub.rb

@@ -1,202 +1,9 @@
 require "jubjub/connection/xmpp_gateway/pubsub"
-
-module Jubjub
-  
-  class Pubsub
-    
-    attr_reader :jid, :node
-    
-    def initialize(jid, node, connection)
-      @jid = Jubjub::Jid.new jid
-      @node = node
-      @connection = connection
-    end
-    
-    def destroy(redirect_jid = nil, redirect_node = nil)
-      redirect_jid = Jubjub::Jid.new(redirect_jid) if redirect_jid
-      @connection.pubsub.destroy jid, node, redirect_jid, redirect_node
-    end
-    
-    def subscribe
-      @connection.pubsub.subscribe jid, node
-    end
-    
-    def unsubscribe(subid = nil)
-      @connection.pubsub.unsubscribe jid, node, subid      
-    end
-    
-    def publish(data, item_id = nil)
-      @connection.pubsub.publish jid, node, data, item_id
-    end
-    
-    def retract(item_id)
-      @connection.pubsub.retract jid, node, item_id
-    end
-    
-    # Hide the connection details and show jid as string for compactness
-    def inspect
-      obj_id = "%x" % (object_id << 1)
-      "#<#{self.class}:0x#{obj_id} @jid=\"#{jid}\" @node=#{node.inspect}>"
-    end
-    
-    def items
-      PubsubItemCollection.new jid, node, @connection
-    end
-    
-  private
-  
-    def method_missing(name, *args, &block)
-      items.send(name, *args, &block)
-    end
-    
-  end
-  
-  class PubsubItemCollection
-    
-    attr_reader :jid, :node
-    
-    def initialize(jid,node,connection)
-      @jid = Jubjub::Jid.new jid
-      @node = node
-      @connection = connection
-    end
-
-    def [](item_num)
-      case item_num
-      when Fixnum
-        items[item_num]
-      else
-        items.find{|i| i.item_id == item_num }        
-      end
-    end
-
-    # Hint that methods are actually applied to list using method_missing
-    def inspect
-      items.inspect
-    end
-
-  private
-
-    def method_missing(name, *args, &block)
-      items.send(name, *args, &block)
-    end
-    
-    def items
-      @items ||= @connection.pubsub.retrieve_items( @jid, @node )
-    end
-    
-  end
-  
-  class PubsubItem
-    
-    attr_reader :jid, :node, :item_id, :data
-    
-    def initialize(jid, node, item_id, data, connection)
-      @jid = Jubjub::Jid.new jid
-      @node = node
-      @item_id = item_id
-      @data = data
-      @connection = connection
-    end
-    
-    # Hide the connection details and show jid as string for compactness
-    def inspect
-      obj_id = "%x" % (object_id << 1)
-      "#<#{self.class}:0x#{obj_id} @jid=\"#{jid}\" @node=#{node.inspect} @item_id=#{item_id.inspect} @data=#{data.inspect}>"
-    end
-    
-    def retract
-      @connection.pubsub.retract jid, node, item_id
-    end
-    
-    def ==(other)
-      other.is_a?( self.class ) &&
-      other.jid     == self.jid &&
-      other.node    == self.node &&
-      other.item_id == self.item_id &&
-      other.data    == self.data
-    end
-    
-  end
-  
-  class PubsubSubscription
-    
-    attr_reader :jid, :node, :subscriber, :subid, :subscription
-    
-    def initialize(jid, node, subscriber, subid, subscription, connection)
-      @jid          = Jubjub::Jid.new jid
-      @node         = node
-      @subscriber   = Jubjub::Jid.new subscriber
-      @subid        = subid
-      @subscription = subscription
-      @connection   = connection
-    end
-    
-    def unsubscribe
-      @connection.pubsub.unsubscribe jid, node, subid
-    end
-    
-    # Hide the connection details and show jid as string for compactness
-    def inspect
-      obj_id = "%x" % (object_id << 1)
-      "#<#{self.class}:0x#{obj_id} @jid=\"#{jid}\" @node=#{node.inspect} @subscriber=\"#{subscriber}\" @subid=#{subid.inspect} @subscription=#{subscription.inspect}>"
-    end
-    
-  end
-  
-  # Uses proxy pattern for syntax sugar
-  # and delaying expensive operations until
-  # required
-  class PubsubCollection
-     
-    attr_reader :jid
-     
-    def initialize(jid, connection)
-      @jid = Jubjub::Jid.new jid
-      @connection = connection
-    end
-    
-    def create(node)
-      @connection.pubsub.create jid, node
-    end
-    
-    def destroy(node, redirect_jid = nil, redirect_node = nil)
-      redirect_jid = Jubjub::Jid.new(redirect_jid) if redirect_jid
-      @connection.pubsub.destroy jid, node, redirect_jid, redirect_node
-    end
-    
-    def subscribe(node)
-      @connection.pubsub.subscribe jid, node
-    end
-    
-    def unsubscribe(node, subid=nil)
-      @connection.pubsub.unsubscribe jid, node, subid
-    end
-    
-    def [](node_num)
-      case node_num
-      when Fixnum
-        list[node_num]
-      else
-        list.find{|p| p.node == node_num }        
-      end
-    end
-    
-    # Hint that methods are actually applied to list using method_missing
-    def inspect
-      list.inspect
-    end
-
-  private
-
-    def method_missing(name, *args, &block)
-      list.send(name, *args, &block)
-    end
-    
-    def list
-      @list ||= @connection.pubsub.list jid
-    end
-    
-  end
-  
-end
+require "jubjub/pubsub/pubsub"
+require "jubjub/pubsub/configuration"
+require "jubjub/pubsub/collection"
+require "jubjub/pubsub/affiliation"
+require "jubjub/pubsub/affiliation_collection"
+require "jubjub/pubsub/item"
+require "jubjub/pubsub/item_collection"
+require "jubjub/pubsub/subscription"

data/lib/jubjub/pubsub/affiliation.rb

@@ -0,0 +1,83 @@
+class Jubjub::Pubsub::Affiliation
+  
+  attr_reader :pubsub_jid, :pubsub_node, :jid, :affiliation
+  
+  def initialize(pubsub_jid, pubsub_node, jid, affiliation, connection)
+    @pubsub_jid = Jubjub::Jid.new pubsub_jid
+    @pubsub_node = pubsub_node
+    @jid = Jubjub::Jid.new jid
+    @affiliation = affiliation
+    @connection = connection
+  end
+
+  # Hide the connection details and show jid as string for compactness
+  def inspect
+    obj_id = "%x" % (object_id << 1)
+    "#<#{self.class}:0x#{obj_id} @pubsub_jid=\"#{pubsub_jid}\" @pubsub_node=#{@pubsub_node} @jid=\"#{jid}\" @affiliation=#{affiliation.inspect}>"
+  end
+  
+  def owner?
+    affiliation == "owner"
+  end
+  
+  def publisher?
+    affiliation == "publisher"
+  end
+  
+  def publish_only?
+    affiliation == "publish-only"
+  end
+  
+  def member?
+    affiliation == "member"
+  end
+  
+  def none?
+    affiliation == "none"
+  end
+  
+  def outcast?
+    affiliation == "outcast"
+  end
+  
+  def set(new_affiliation)
+    old_affiliation = @affiliation
+    @affiliation = new_affiliation
+    r = @connection.pubsub.modify_affiliations pubsub_jid, pubsub_node, self
+    @affiliation = old_affiliation unless r
+    r
+  end
+  
+  def set_owner
+    set 'owner'
+  end
+  
+  def set_publisher
+    set 'publisher'    
+  end
+  
+  def set_publish_only
+    set 'publish-only'    
+  end
+  
+  def set_member
+    set 'member'
+  end
+  
+  def set_none
+    set 'none'
+  end
+  
+  def set_outcast
+    set 'outcast'
+  end
+  
+  def ==(other)
+    other.is_a?( self.class ) &&
+    other.pubsub_jid  == self.pubsub_jid &&
+    other.pubsub_node == self.pubsub_node &&
+    other.jid         == self.jid &&
+    other.affiliation == self.affiliation
+  end
+  
+end

data/lib/jubjub/pubsub/affiliation_collection.rb

@@ -0,0 +1,38 @@
+class Jubjub::Pubsub::AffiliationCollection
+  
+  attr_reader :jid, :node
+  
+  def initialize(jid,node,connection)
+    @jid = Jubjub::Jid.new jid
+    @node = node
+    @connection = connection
+  end
+
+  def [](jid_num)
+    case jid_num
+    when Fixnum
+      affiliations[jid_num]
+    when Jubjub::Jid
+      affiliations.find{|i| i.jid == jid_num } || Jubjub::Pubsub::Affiliation.new( jid, node, jid_num, 'none', @connection )
+    else
+      j = Jubjub::Jid.new( jid_num )
+      affiliations.find{|i| i.jid == j } || Jubjub::Pubsub::Affiliation.new( jid, node, j, 'none', @connection )
+    end
+  end
+
+  # Hint that methods are actually applied to list using method_missing
+  def inspect
+    affiliations.inspect
+  end
+
+private
+
+  def method_missing(name, *args, &block)
+    affiliations.send(name, *args, &block)
+  end
+  
+  def affiliations
+    @affiliations ||= @connection.pubsub.retrieve_affiliations( @jid, @node )
+  end
+  
+end

data/lib/jubjub/pubsub/collection.rb

@@ -0,0 +1,68 @@
+# Uses proxy pattern for syntax sugar
+# and delaying expensive operations until
+# required
+class Jubjub::Pubsub::Collection
+   
+  attr_reader :jid
+   
+  def initialize(jid, connection)
+    @jid = Jubjub::Jid.new jid
+    @connection = connection
+  end
+  
+  def create(node)
+    @connection.pubsub.create jid, node
+  end
+  
+  def create(node, &block)
+    config = nil
+    if block_given?
+      # Configure node
+      config = @connection.pubsub.default_configuration jid
+      yield config
+    end
+    @connection.pubsub.create jid, node, config
+  end
+  
+  def destroy(node, redirect_jid = nil, redirect_node = nil)
+    redirect_jid = Jubjub::Jid.new(redirect_jid) if redirect_jid
+    @connection.pubsub.destroy jid, node, redirect_jid, redirect_node
+  end
+  
+  def purge(node)
+    @connection.pubsub.purge jid, node
+  end
+  
+  def subscribe(node)
+    @connection.pubsub.subscribe jid, node
+  end
+  
+  def unsubscribe(node, subid=nil)
+    @connection.pubsub.unsubscribe jid, node, subid
+  end
+  
+  def [](node_num)
+    case node_num
+    when Fixnum
+      list[node_num]
+    else
+      list.find{|p| p.node == node_num } || Jubjub::Pubsub.new( jid, node_num, @connection )
+    end
+  end
+  
+  # Hint that methods are actually applied to list using method_missing
+  def inspect
+    list.inspect
+  end
+
+private
+
+  def method_missing(name, *args, &block)
+    list.send(name, *args, &block)
+  end
+  
+  def list
+    @list ||= @connection.pubsub.list jid
+  end
+  
+end