vines 0.1.1 → 0.2.0

data/lib/vines/stanza/iq/roster.rb

@@ -77,13 +77,8 @@ module Vines
           raise StanzaErrors::ItemNotFound.new(self, 'modify') unless contact
           if router.local_jid?(contact.jid)
             user = storage(contact.jid.domain).find_user(contact.jid)
-            remove(contact, user)
-          else
-            remove(contact, nil)
           end
-        end
 
-        def remove(contact, user=nil)
           if user && user.contact(stream.user.jid)
             user.contact(stream.user.jid).subscription = 'none'
             user.contact(stream.user.jid).ask = nil
@@ -93,52 +88,53 @@ module Vines
             storage(save.jid.domain).save_user(save)
             stream.update_user_streams(save)
           end
+
           send_result_iq
           push_roster_updates(stream.user.jid, Contact.new(
             :jid => contact.jid,
             :subscription => 'remove'))
 
-          presence = [%w[to unsubscribe], %w[from unsubscribed]].map do |meth, type|
-            if contact.send("subscribed_#{meth}?")
-              doc = Document.new
-              doc.create_element('presence',
-                'from' => stream.user.jid.bare.to_s,
-                'to'   => contact.jid.to_s,
-                'type' => type)
+          if router.local_jid?(contact.jid)
+            send_unavailable(stream.user.jid, contact.jid) if contact.subscribed_from?
+            send_unsubscribe(contact)
+            if user.contact(stream.user.jid)
+              push_roster_updates(contact.jid, user.contact(stream.user.jid))
             end
+          else
+            send_unsubscribe(contact)
+          end
+        end
+
+        # Notify the contact that it's been removed from the user's roster
+        # and no longer has any presence relationship with the user.
+        def send_unsubscribe(contact)
+          presence = [%w[to unsubscribe], %w[from unsubscribed]].map do |meth, type|
+            presence(contact.jid, type) if contact.send("subscribed_#{meth}?")
           end.compact
 
           if router.local_jid?(contact.jid)
             router.interested_resources(contact.jid).each do |recipient|
               presence.each {|el| recipient.write(el) }
-              doc = Document.new
-              el = doc.create_element('presence',
-                'from' => stream.user.jid.bare.to_s,
-                'to'   => recipient.user.jid.to_s,
-                'type' => 'unavailable')
-              recipient.write(el)
             end
-            push_roster_updates(contact.jid, Contact.new(
-              :jid => stream.user.jid,
-              :subscription => 'none'))
           else
             presence.each {|el| router.route(el) }
           end
         end
 
+        def presence(to, type)
+          doc = Document.new
+          doc.create_element('presence',
+            'from' => stream.user.jid.bare.to_s,
+            'id'   => Kit.uuid,
+            'to'   => to.to_s,
+            'type' => type)
+        end
+
         # Send an iq set stanza to the user's interested resources, letting them
         # know their roster has been updated.
         def push_roster_updates(to, contact)
-          doc = Document.new
-          el = doc.create_element('iq', 'type' => 'set') do |node|
-            node << doc.create_element('query', 'xmlns' => NAMESPACES[:roster]) do |query|
-              query << contact.to_roster_xml
-            end
-          end
           router.interested_resources(to).each do |recipient|
-            el['id'] = Kit.uuid
-            el['to'] = recipient.user.jid.to_s
-            recipient.write(el)
+            contact.send_roster_push(recipient)
           end
         end
 

data/lib/vines/stanza/presence.rb

@@ -81,18 +81,6 @@ module Vines
         router.route(probe)
       end
 
-      def send_subscribed_roster_push(recipient, jid, state)
-        doc = Document.new
-        node = doc.create_element('iq',
-          'id'  => Kit.uuid,
-          'to'  => recipient.user.jid.to_s,
-          'type' => 'set')
-        node << doc.create_element('query', 'xmlns' => NAMESPACES[:roster]) do |query|
-          query << doc.create_element('item', 'jid' => jid.to_s, 'subscription' => state)
-        end
-        recipient.write(node)
-      end
-
       def auto_reply_to_subscription_request(from, type)
         doc = Document.new
         node = doc.create_element('presence') do |el|

data/lib/vines/stanza/presence/subscribe.rb

@@ -13,16 +13,15 @@ module Vines
         def process_outbound
           self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-          route unless local?
+          local? ? process_inbound : route
 
           stream.user.request_subscription(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
 
-          process_inbound if local?
-
+          contact = stream.user.contact(to)
           router.interested_resources(stream.user.jid).each do |recipient|
-            send_subscribe_roster_push(recipient, stream.user.contact(to))
+            contact.send_roster_push(recipient)
           end
         end
 
@@ -44,22 +43,6 @@ module Vines
             end
           end
         end
-
-        private
-
-        def send_subscribe_roster_push(recipient, contact)
-          doc = Document.new
-          node = doc.create_element('iq') do |el|
-            el['id'] = Kit.uuid
-            el['to'] = recipient.user.jid.to_s
-            el['type'] = 'set'
-            el << doc.create_element('query') do |query|
-              query.default_namespace = NAMESPACES[:roster]
-              query << contact.to_roster_xml
-            end
-          end
-          recipient.write(node)
-        end
       end
     end
   end

data/lib/vines/stanza/presence/subscribed.rb

@@ -13,22 +13,23 @@ module Vines
         def process_outbound
           self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-          route unless local?
+          local? ? process_inbound : route
 
           stream.user.add_subscription_from(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
 
+          contact = stream.user.contact(to)
           router.interested_resources(stream.user.jid).each do |recipient|
-            send_subscribed_roster_push(recipient, to, stream.user.contact(to).subscription)
+            contact.send_roster_push(recipient)
           end
 
           presences = router.available_resources(stream.user.jid).map do |c|
-            doc = Document.new
-            doc.create_element('presence',
-              'from' => c.user.jid.to_s,
-              'id'   => Kit.uuid,
-              'to'   => to.to_s)
+            c.last_broadcast_presence.clone.tap do |node|
+              node['from'] = c.user.jid.to_s
+              node['id'] = Kit.uuid
+              node['to'] = to.to_s
+            end
           end
 
           if local?
@@ -38,8 +39,6 @@ module Vines
           else
             presences.each {|el| router.route(el) }
           end
-
-          process_inbound if local?
         end
 
         def process_inbound
@@ -55,7 +54,7 @@ module Vines
 
           router.interested_resources(to).each do |recipient|
             recipient.write(@node)
-            send_subscribed_roster_push(recipient, stream.user.jid.bare, contact.subscription)
+            contact.send_roster_push(recipient)
           end
         end
       end

data/lib/vines/stanza/presence/unsubscribe.rb

@@ -13,18 +13,17 @@ module Vines
         def process_outbound
           self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-          route unless local?
+
+          return unless stream.user.subscribed_to?(to)
+          local? ? process_inbound : route
 
           stream.user.remove_subscription_to(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
 
-          process_inbound if local?
-
-          if contact = stream.user.contact(to)
-            router.interested_resources(stream.user.jid).each do |recipient|
-              send_subscribed_roster_push(recipient, to, contact.subscription)
-            end
+          contact = stream.user.contact(to)
+          router.interested_resources(stream.user.jid).each do |recipient|
+            contact.send_roster_push(recipient)
           end
         end
 
@@ -41,15 +40,9 @@ module Vines
 
           router.interested_resources(to).each do |recipient|
             recipient.write(@node)
-            send_subscribed_roster_push(recipient, stream.user.jid.bare, contact.subscription)
-            doc = Document.new
-            el = doc.create_element('presence',
-              'from' => stream.user.jid.bare.to_s,
-              'id'   => Kit.uuid,
-              'to'   => recipient.user.jid.to_s,
-              'type' => 'unavailable')
-            recipient.write(el)
+            contact.send_roster_push(recipient)
           end
+          send_unavailable(to, stream.user.jid.bare)
         end
       end
     end

data/lib/vines/stanza/presence/unsubscribed.rb

@@ -13,19 +13,19 @@ module Vines
         def process_outbound
           self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-          route unless local?
+
+          return unless stream.user.subscribed_from?(to)
+          send_unavailable(stream.user.jid, to)
+          local? ? process_inbound : route
 
           stream.user.remove_subscription_from(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
 
-          if contact = stream.user.contact(to)
-            router.interested_resources(stream.user.jid).each do |recipient|
-              send_subscribed_roster_push(recipient, to, contact.subscription)
-            end
+          contact = stream.user.contact(to)
+          router.interested_resources(stream.user.jid).each do |recipient|
+            contact.send_roster_push(recipient)
           end
-
-          process_inbound if local?
         end
 
         def process_inbound
@@ -41,7 +41,7 @@ module Vines
 
           router.interested_resources(to).each do |recipient|
             recipient.write(@node)
-            send_subscribed_roster_push(recipient, stream.user.jid.bare, contact.subscription)
+            contact.send_roster_push(recipient)
           end
         end
       end

data/lib/vines/storage.rb

@@ -168,6 +168,34 @@ module Vines
       raise 'subclass must implement'
     end
 
+    # Return the Nokogiri::XML::Node for the XML fragment stored for this JID.
+    # Return nil if the fragment could not be found. JID may be +nil+, a
+    # +String+, or a +Vines::JID+ object. It may be a bare JID or a full JID.
+    # Implementations of this method must convert the JID to a bare JID before
+    # searching for the fragment in the database.
+    #
+    # Private XML storage uniquely identifies fragments by JID, root element name,
+    # and root element namespace.
+    #
+    # root = Nokogiri::XML('<custom xmlns="urn:custom:ns"/>').root
+    # fragment = storage.find_fragment('alice@wonderland.lit', root)
+    # puts fragment.nil?
+    def find_fragment(jid, node)
+      raise 'subclass must implement'
+    end
+
+    # Save the XML fragment to the database and return when the save is complete.
+    # JID may be a +String+ or a +Vines::JID+ object.  It may be a bare JID or a
+    # full JID. Implementations of this method must convert the JID to a bare
+    # JID before saving the fragment. Fragment is a +Nokogiri::XML::Node+ object.
+    #
+    # fragment = Nokogiri::XML('<custom xmlns="urn:custom:ns">some data</custom>').root
+    # storage.save_fragment('alice@wonderland.lit', fragment)
+    # puts 'saved'
+    def save_fragment(jid, fragment)
+      raise 'subclass must implement'
+    end
+
     private
 
     # Return true if any of the arguments are nil or empty strings.

data/lib/vines/storage/couchdb.rb

@@ -84,8 +84,37 @@ module Vines
       end
       fiber :save_vcard
 
+      def find_fragment(jid, node)
+        jid = JID.new(jid || '').bare.to_s
+        if jid.empty? then yield; return end
+        get(fragment_id(jid, node)) do |doc|
+          fragment = if doc && doc['type'] == 'Fragment'
+            Nokogiri::XML(doc['xml']).root rescue nil
+          end
+          yield fragment
+        end
+      end
+      fiber :find_fragment
+
+      def save_fragment(jid, node, &callback)
+        jid = JID.new(jid).bare.to_s
+        id = fragment_id(jid, node)
+        get(id) do |doc|
+          doc ||= {'_id' => id}
+          doc['type'] = 'Fragment'
+          doc['xml'] = node.to_xml
+          save_doc(doc, &callback)
+        end
+      end
+      fiber :save_fragment
+
       private
 
+      def fragment_id(jid, node)
+        id = Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
+        "fragment:#{jid}:#{id}"
+      end
+
       def url(config)
         scheme = config[:tls] ? 'https' : 'http'
         user, password = config.values_at(:username, :password)

data/lib/vines/storage/local.rb

@@ -61,6 +61,28 @@ module Vines
           f.write(card.to_xml)
         end
       end
+
+      def find_fragment(jid, node)
+        jid = JID.new(jid || '').bare.to_s
+        return if jid.empty?
+        file = File.join(@dir, fragment_id(jid, node))
+        Nokogiri::XML(File.read(file)).root rescue nil
+      end
+
+      def save_fragment(jid, node)
+        jid = JID.new(jid).bare.to_s
+        file = File.join(@dir, fragment_id(jid, node))
+        File.open(file, 'w') do |f|
+          f.write(node.to_xml)
+        end
+      end
+
+      private
+
+      def fragment_id(jid, node)
+        id = Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
+        "#{jid}-#{id}.fragment"
+      end
     end
   end
 end

data/lib/vines/storage/redis.rb

@@ -74,8 +74,34 @@ module Vines
       end
       fiber :save_vcard
 
+      def find_fragment(jid, node)
+        jid = JID.new(jid || '').bare.to_s
+        if jid.empty? then yield; return end
+        redis.hget("fragments:#{jid}", fragment_id(node)) do |response|
+          fragment = if response
+            doc = JSON.parse(response) rescue nil
+            Nokogiri::XML(doc['xml']).root rescue nil
+          end
+          yield fragment
+        end
+      end
+      fiber :find_fragment
+
+      def save_fragment(jid, node)
+        jid = JID.new(jid).bare.to_s
+        doc = {:xml => node.to_xml}
+        redis.hset("fragments:#{jid}", fragment_id(node), doc.to_json) do
+          yield
+        end
+      end
+      fiber :save_fragment
+
       private
 
+      def fragment_id(node)
+        Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
+      end
+
       # Retrieve the hash stored at roster:jid and yield an array of
       # +Vines::Contact+ objects to the provided block.
       #

data/lib/vines/storage/sql.rb

@@ -8,9 +8,13 @@ module Vines
       class Contact < ActiveRecord::Base
         belongs_to :user
       end
+      class Fragment < ActiveRecord::Base
+        belongs_to :user
+      end
       class Group < ActiveRecord::Base; end
       class User < ActiveRecord::Base
         has_many :contacts
+        has_many :fragments
       end
 
       %w[adapter host port database username password pool].each do |name|
@@ -38,7 +42,7 @@ module Vines
 
         jid = JID.new(jid || '').bare.to_s
         return if jid.empty?
-        xuser = by_jid(jid)
+        xuser = user_by_jid(jid)
         return Vines::User.new(:jid => jid).tap do |user|
           user.name, user.password = xuser.name, xuser.password
           xuser.contacts.each do |contact|
@@ -57,7 +61,7 @@ module Vines
       def save_user(user)
         ActiveRecord::Base.clear_reloadable_connections!
 
-        xuser = by_jid(user.jid) || Sql::User.new(:jid => user.jid.bare.to_s)
+        xuser = user_by_jid(user.jid) || Sql::User.new(:jid => user.jid.bare.to_s)
         xuser.name = user.name
         xuser.password = user.password
 
@@ -97,7 +101,7 @@ module Vines
 
         jid = JID.new(jid || '').bare.to_s
         return if jid.empty?
-        if xuser = by_jid(jid)
+        if xuser = user_by_jid(jid)
           Nokogiri::XML(xuser.vcard).root rescue nil
         end
       end
@@ -106,7 +110,7 @@ module Vines
       def save_vcard(jid, card)
         ActiveRecord::Base.clear_reloadable_connections!
 
-        xuser = by_jid(jid)
+        xuser = user_by_jid(jid)
         if xuser
           xuser.vcard = card.to_xml
           xuser.save
@@ -114,6 +118,31 @@ module Vines
       end
       defer :save_vcard
 
+      def find_fragment(jid, node)
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        jid = JID.new(jid || '').bare.to_s
+        return if jid.empty?
+        if fragment = fragment_by_jid(jid, node)
+          Nokogiri::XML(fragment.xml).root rescue nil
+        end
+      end
+      defer :find_fragment
+
+      def save_fragment(jid, node)
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        jid = JID.new(jid).bare.to_s
+        fragment = fragment_by_jid(jid, node) ||
+          Sql::Fragment.new(
+            :user => user_by_jid(jid),
+            :root => node.name,
+            :namespace => node.namespace.href)
+        fragment.xml = node.to_xml
+        fragment.save
+      end
+      defer :save_fragment
+
       # Create the tables and indexes used by this storage engine.
       def create_schema(args={})
         ActiveRecord::Base.clear_reloadable_connections!
@@ -148,6 +177,14 @@ module Vines
             t.integer :group_id,   :null => false
           end
           add_index :contacts_groups, [:contact_id, :group_id], :unique => true
+
+          create_table :fragments, :force => args[:force] do |t|
+            t.integer :user_id,   :null => false
+            t.string  :root,      :limit => 1000, :null => false
+            t.string  :namespace, :limit => 1000, :null => false
+            t.text    :xml,       :null => false
+          end
+          add_index :fragments, [:user_id, :root, :namespace], :unique => true
         end
       end
 
@@ -161,11 +198,17 @@ module Vines
         Sql::Group.has_and_belongs_to_many :contacts
       end
 
-      def by_jid(jid)
+      def user_by_jid(jid)
         jid = JID.new(jid).bare.to_s
         Sql::User.find_by_jid(jid, :include => {:contacts => :groups})
       end
 
+      def fragment_by_jid(jid, node)
+        jid = JID.new(jid).bare.to_s
+        clause = 'user_id=(select id from users where jid=?) and root=? and namespace=?'
+        Sql::Fragment.where(clause, jid, node.name, node.namespace.href).first
+      end
+
       def groups(contact)
         contact.groups.map {|name| Sql::Group.find_or_create_by_name(name.strip) }
       end