julien51-babylon 0.0.9 → 0.0.10

data/README.rdoc

@@ -8,13 +8,9 @@ This framework can use both an XMPP Component (XEP-0114) and an XMPP Client. How
 
 == FEATURES/PROBLEMS:
 
-* This hasn't been tested. 
-
 == ROADMAP :
 
 - Instead of passing the stanzas as Nokogiri:XML:Node elements we should find a way to pass an "agnostic" ruby data-structure, so that app developers don't have to learn/know/understand Nokogiri
-- HELPERS : 
-    * strip jids (...) 
 - Improve the Client Connection to support other authentication than PLAIN SASL
 
 == SYNOPSIS:
@@ -83,11 +79,21 @@ Compared to Rails, we are using accessors (and not @variables assigned in the co
     
     script/component
 
-== ADDITIONAL INFORMATION
 
-This code hasn't been tested at all! (yes, i know it's bad, but I couldn't have rspec working with eventmachine) Feel free to pull, branch, improve {code|specs|tests|docs} and we will merge it!
+If you just want to make use of the connection classes (Client or Component), you can just call the following :
+
+Babylon::ClientConnection.connect(params, handler) 
+or,
+Babylon::ComponentConnection.connect(params, handler) 
+
+where params is a hash for all the necessary information to connect, and handler is an object that will receive the callbacks. Right now 3 callbacks are supported:
+
+on_connected, on_disconnected and on_stanza
+
+
+== ADDITIONAL INFORMATION
 
-If you used a version before 0.0.6, please change your routes to use the new router DSL. (See template for more help). It shouldn't be long... sorry for that.
+This code hasn't been 100% tested. Feel free to pull, branch, improve {code|specs|tests|docs} and we will merge it!
 
 == REQUIREMENTS:
 

data/lib/babylon.rb

@@ -73,11 +73,6 @@ module Babylon
   def self.config
     @@config
   end
-
-  ##
-  # Authentication Error (wrong password/jid combination). Used for Clients and Components
-  class AuthenticationError < Exception 
-  end
-
+  
 end
 

data/lib/babylon/client_connection.rb

@@ -9,7 +9,6 @@ module Babylon
     require 'base64'
     require 'resolv'
 
-
     attr_reader :binding_iq_id, :session_iq_id
 
     ##
@@ -22,8 +21,8 @@ module Babylon
     ##
     # Connects the ClientConnection based on SRV records for the jid's domain, if no host or port has been specified.
     # In any case, we give priority to the specified host and port.
-    def self.connect(params, &block)
-      return super(params, &block) if params["host"] && params["port"]
+    def self.connect(params, handler = nil)
+      return super(params, handler) if params["host"] && params["port"]
 
       begin
         begin
@@ -42,7 +41,7 @@ module Babylon
             begin
               params["host"] = record.target.to_s
               params["port"] = Integer(record.port)
-              super(params, &block)
+              super(params, handler)
               # Success
               break
             rescue SocketError, Errno::ECONNREFUSED
@@ -76,115 +75,116 @@ module Babylon
     # Called upon stanza reception
     # Marked as connected when the client has been SASLed, authenticated, biund to a resource and when the session has been created
     def receive_stanza(stanza)
-      case @state
-      when :connected
-        super # Can be dispatched
-
-      when :wait_for_stream
-        if stanza.name == "stream:stream" && stanza.attributes['id']
-          @state = :wait_for_auth_mechanisms unless @success
-          @state = :wait_for_bind if @success
-        end
+      begin
+        case @state
+        when :connected
+          super # Can be dispatched
+
+        when :wait_for_stream
+          if stanza.name == "stream:stream" && stanza.attributes['id']
+            @state = :wait_for_auth_mechanisms unless @success
+            @state = :wait_for_bind if @success
+          end
 
-      when :wait_for_auth_mechanisms
-        if stanza.name == "stream:features"
-          if stanza.at("starttls") # we shall start tls
-            starttls = Nokogiri::XML::Node.new("starttls", @outstream)
-            starttls["xmlns"] = "urn:ietf:params:xml:ns:xmpp-tls"
-            send(starttls)
-            @state = :wait_for_proceed
-          elsif stanza.at("mechanisms") # tls is ok
-            if stanza.at("mechanisms/[contains(mechanism,'PLAIN')]")
-              # auth_text = "#{jid.strip}\x00#{jid.node}\x00#{password}"
-              auth = Nokogiri::XML::Node.new("auth", @outstream)
-              auth['mechanism'] = "PLAIN"
-              auth['xmlns'] = "urn:ietf:params:xml:ns:xmpp-sasl"
-              auth.content = Base64::encode64([jid, jid.split("@").first, @password].join("\000")).gsub(/\s/, '')
-              send(auth)
-              @state = :wait_for_success
+        when :wait_for_auth_mechanisms
+          if stanza.name == "stream:features"
+            if stanza.at("starttls") # we shall start tls
+              starttls = Nokogiri::XML::Node.new("starttls", @outstream)
+              starttls["xmlns"] = "urn:ietf:params:xml:ns:xmpp-tls"
+              send(starttls)
+              @state = :wait_for_proceed
+            elsif stanza.at("mechanisms") # tls is ok
+              if stanza.at("mechanisms/[contains(mechanism,'PLAIN')]")
+                # auth_text = "#{jid.strip}\x00#{jid.node}\x00#{password}"
+                auth = Nokogiri::XML::Node.new("auth", @outstream)
+                auth['mechanism'] = "PLAIN"
+                auth['xmlns'] = "urn:ietf:params:xml:ns:xmpp-sasl"
+                auth.content = Base64::encode64([jid, jid.split("@").first, @password].join("\000")).gsub(/\s/, '')
+                send(auth)
+                @state = :wait_for_success
+              end
             end
           end
-        end
 
-      when :wait_for_success
-        if stanza.name == "success" # Yay! Success
-          @success = true
-          @state = :wait_for_stream
-          @parser.reset
-          send @outstream.root.to_xml.split('<paste_content_here/>').first
-        elsif stanza.name == "failure"
-          if stanza.at("bad-auth") || stanza.at("not-authorized")
-            raise AuthenticationError
+        when :wait_for_success
+          if stanza.name == "success" # Yay! Success
+            @success = true
+            @state = :wait_for_stream
+            @parser.reset
+            send @outstream.root.to_xml.split('<paste_content_here/>').first
+          elsif stanza.name == "failure"
+            if stanza.at("bad-auth") || stanza.at("not-authorized")
+              raise AuthenticationError
+            else
+            end
           else
+            # Hum Failure...
           end
-        else
-          # Hum Failure...
-        end
 
-      when :wait_for_bind
-        if stanza.name == "stream:features"
-          if stanza.at("bind")
-            # Let's build the binding_iq
-            @binding_iq_id = Integer(rand(10000))
-            builder = Nokogiri::XML::Builder.new do
-              iq(:type => "set", :id => @context.binding_iq_id) do
-                bind(:xmlns => "urn:ietf:params:xml:ns:xmpp-bind")  do                
-                  if @context.jid.split("/").size == 2 
-                    resource(@context.jid.split("/").last)
-                  else
-                    resource("babylon_client_#{@context.binding_iq_id}")
+        when :wait_for_bind
+          if stanza.name == "stream:features"
+            if stanza.at("bind")
+              # Let's build the binding_iq
+              @binding_iq_id = Integer(rand(10000))
+              builder = Nokogiri::XML::Builder.new do
+                iq(:type => "set", :id => @context.binding_iq_id) do
+                  bind(:xmlns => "urn:ietf:params:xml:ns:xmpp-bind")  do                
+                    if @context.jid.split("/").size == 2 
+                      resource(@context.jid.split("/").last)
+                    else
+                      resource("babylon_client_#{@context.binding_iq_id}")
+                    end
                   end
                 end
               end
+              iq = @outstream.add_child(builder.doc.root)
+              send(iq)
+              @state = :wait_for_confirmed_binding
             end
-            iq = @outstream.add_child(builder.doc.root)
-            send(iq)
-            @state = :wait_for_confirmed_binding
           end
-        end
 
-      when :wait_for_confirmed_binding
-        if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  @binding_iq_id
-          if stanza.at("jid") 
-            jid= stanza.at("jid").text
+        when :wait_for_confirmed_binding
+          if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  @binding_iq_id
+            if stanza.at("jid") 
+              jid= stanza.at("jid").text
+            end
           end
-        end
-        # And now, we must initiate the session
-        @session_iq_id = Integer(rand(10000))
-        builder = Nokogiri::XML::Builder.new do
-          iq(:type => "set", :id => @context.session_iq_id) do
-            session(:xmlns => "urn:ietf:params:xml:ns:xmpp-session")
+          # And now, we must initiate the session
+          @session_iq_id = Integer(rand(10000))
+          builder = Nokogiri::XML::Builder.new do
+            iq(:type => "set", :id => @context.session_iq_id) do
+              session(:xmlns => "urn:ietf:params:xml:ns:xmpp-session")
+            end
+          end
+          iq = @outstream.add_child(builder.doc.root)
+          send(iq)
+          @state = :wait_for_confirmed_session
+
+        when :wait_for_confirmed_session
+          if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  @session_iq_id && stanza.at("session")
+            # And now, send a presence!
+            presence = Nokogiri::XML::Node.new("presence", @outstream)
+            send(presence)
+            @handler.on_connected(self) if @handler
+            @state = :connected
           end
-        end
-        iq = @outstream.add_child(builder.doc.root)
-        send(iq)
-        @state = :wait_for_confirmed_session
-
-      when :wait_for_confirmed_session
-        if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  @session_iq_id && stanza.at("session")
-          # And now, send a presence!
-          presence = Nokogiri::XML::Node.new("presence", @outstream)
-          send(presence)
-          @connection_callback.call(self) if @connection_callback
-          @state = :connected
-        end
 
-      when :wait_for_proceed
-        start_tls() # starting TLS
-        @state = :wait_for_stream
-        @parser.reset
-        send @outstream.root.to_xml.split('<paste_content_here/>').first
+        when :wait_for_proceed
+          start_tls() # starting TLS
+          @state = :wait_for_stream
+          @parser.reset
+          send @outstream.root.to_xml.split('<paste_content_here/>').first
+        end
+      rescue
+        Babylon.logger.error("#{$!}:\n#{$!.backtrace.join("\n")}")
       end
-    rescue
-      Babylon.logger.error("#{$!}:\n#{$!.backtrace.join("\n")}")
     end
-  end
 
-  ##
-  # Namespace of the client
-  def stream_namespace
-    "jabber:client"
-  end
+    ##
+    # Namespace of the client
+    def stream_namespace
+      "jabber:client"
+    end
 
-end
+  end
 end

data/lib/babylon/component_connection.rb

@@ -23,8 +23,8 @@ module Babylon
           paste_content_here #  The stream:stream element should be cut here ;)
         end
       end
-      @start_stream, @stop_stream = builder.to_xml.split('<paste_content_here/>')
-      send(@start_stream)
+      start, stop = builder.to_xml.split('<paste_content_here/>')
+      send(start)
     end
 
     ##
@@ -39,10 +39,7 @@ module Babylon
         if stanza.name == "stream:stream" && stanza.attributes['id']
           # This means the XMPP session started!
           # We must send the handshake now.
-          hash = Digest::SHA1::hexdigest(stanza.attributes['id'].content + @password)
-          handshake = Nokogiri::XML::Node.new("handshake", stanza.document)
-          handshake.content = hash
-          send(handshake)
+          send(handshake(stanza))
           @state = :wait_for_handshake
         else
           raise
@@ -50,7 +47,7 @@ module Babylon
 
       when :wait_for_handshake
         if stanza.name == "handshake"
-          @connection_callback.call(self) if @connection_callback
+          @handler.on_connected(self) if @handler
           @state = :connected
         elsif stanza.name == "stream:error"
           raise AuthenticationError
@@ -67,5 +64,15 @@ module Babylon
       'jabber:component:accept'
     end
     
+    private
+    
+    def handshake(stanza)
+      hash = Digest::SHA1::hexdigest(stanza.attributes['id'].content + @password)
+      handshake = Nokogiri::XML::Node.new("handshake", stanza.document)
+      handshake.content = hash
+      handshake
+    end
+    
+    
   end
 end

data/lib/babylon/router.rb

@@ -101,7 +101,8 @@ module Babylon
       raise("No controller given for route") unless params["controller"]
       raise("No action given for route") unless params["action"]
       @priority   = params["priority"] || 0
-      @xpath      = params["xpath"]
+      @xpath      = params["xpath"] if params["xpath"]
+      @css        = params["css"] if params["css"]
       @controller = Kernel.const_get("#{params["controller"].capitalize}Controller")
       @action     = params["action"]
     end
@@ -109,7 +110,11 @@ module Babylon
     ##
     # Checks that the route matches the stanzas and calls the the action on the controller
     def accepts?(stanza)
-      stanza.xpath(@xpath, XpathHelper.new).first ? self : false
+      if @xpath
+        stanza.xpath(@xpath, XpathHelper.new).first ? self : false
+      elsif @css
+        stanza.css(@css).first ? self : false
+      end
     end
     
   end

data/lib/babylon/router/dsl.rb

@@ -14,6 +14,12 @@ module Babylon
         @routes << {"xpath" => path}
         self
       end
+      
+      # Match a css.
+      def css(path)
+        @routes << {"css" => path}
+        self
+      end
 
       # Set the priority of the last created route.
       def priority(n)

data/lib/babylon/runner.rb

@@ -30,22 +30,18 @@ module Babylon
         
         config_file = File.open('config/config.yaml')
         
-        
         # Caching views in production mode.
         if Babylon.environment == "production"
           Babylon.cache_views
         end
         
+        Babylon.config = YAML.load(config_file)[Babylon.environment] 
         
-        Babylon.config = YAML.load(config_file)[Babylon.environment]
-        
-        params, on_connected = Babylon.config.merge({:on_stanza => Babylon::CentralRouter.method(:route)}), Babylon::CentralRouter.method(:connected)
-        
-        case Babylon.config["application_type"]
+        case Babylon.config["application_type"] 
           when "client"
-            Babylon::ClientConnection.connect(params, &on_connected)
+            Babylon::ClientConnection.connect(Babylon.config, self) 
           else # By default, we assume it's a component
-            Babylon::ComponentConnection.connect(params, &on_connected)
+            Babylon::ComponentConnection.connect(Babylon.config, self) 
         end
         
         # And finally, let's allow the application to do all it wants to do after we started the EventMachine!
@@ -53,5 +49,23 @@ module Babylon
       end
     end
     
+    ## 
+    # Will be called by the connection class once it is connected to the server.
+    def on_connected(connection)
+      Babylon::CentralRouter.method(:connected)
+    end
+    
+    ##
+    # Will be called by the connection class upon disconnection.
+    def on_disconnected()
+      EventMachine.stop_event_loop
+    end
+    
+    ##
+    # Will be called by the connection class when it receives and parses a stanza.
+    def on_stanza(stanza)
+      Babylon::CentralRouter.method(:route)
+    end
+    
   end
 end

data/lib/babylon/xmpp_connection.rb

@@ -8,6 +8,10 @@ module Babylon
   # xml-not-well-formed Exception
   class XmlNotWellFormed < Exception; end
   
+  ##
+  # Authentication Error (wrong password/jid combination). Used for Clients and Components
+  class AuthenticationError < Exception; end
+  
   ##
   # This class is in charge of handling the network connection to the XMPP server.
   class XmppConnection < EventMachine::Connection
@@ -18,9 +22,9 @@ module Babylon
     # Connects the XmppConnection to the right host with the right port. I
     # It passes itself (as handler) and the configuration
     # This can very well be overwritten by subclasses.
-    def self.connect(params, &block)
+    def self.connect(params, handler)
       Babylon.logger.debug("CONNECTING TO #{params["host"]}:#{params["port"]}") # Very low level Logging
-      EventMachine.connect(params["host"], params["port"], self, params.merge({:on_connection => block}))
+      EventMachine.connect(params["host"], params["port"], self, params.merge({"handler" => handler}))
     end
     
     def connection_completed
@@ -31,45 +35,39 @@ module Babylon
     # Called when the connection is terminated and stops the event loop
     def unbind()
       Babylon.logger.debug("DISCONNECTED") # Very low level Logging
-      EventMachine::stop_event_loop
-      raise NotConnected
+      @handler.on_disconnected(self) if @handler
     end
 
     ## 
     # Instantiate the Handler (called internally by EventMachine) and attaches a new XmppParser
     def initialize(params)
       super()
-      @last_stanza_received = nil
-      @last_stanza_sent = nil
       @jid = params["jid"]
       @password = params["password"]
       @host = params["host"]
       @port = params["port"]
-      @stanza_callback = params[:on_stanza]
-      @connection_callback = params[:on_connection]
+      @handler = params["handler"]
       @parser = XmppParser.new(&method(:receive_stanza))
     end
 
     ##
     # Called when a full stanza has been received and returns it to the central router to be sent to the corresponding controller.
     def receive_stanza(stanza)
-      @last_stanza_received = stanza
       Babylon.logger.debug("PARSED : #{stanza.to_xml}")
       # If not handled by subclass (for authentication)
       case stanza.name
       when "stream:error"
-        if stanza.at("xml-not-well-formed")
-          Babylon.logger.error("DISCONNECTED DUE TO MALFORMED STANZA : \n#{@last_stanza_sent}")
+        if !stanza.children.empty? and stanza.children.first.name == "xml-not-well-formed"
           # <stream:error><xml-not-well-formed xmlns:xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>
+          Babylon.logger.error("DISCONNECTED DUE TO MALFORMED STANZA")
           raise XmlNotWellFormed
         end
         # In any case, we need to close the connection.
         close_connection
       else
-        @stanza_callback.call(stanza) if @stanza_callback
-      end
-      
-    end
+        @handler.on_stanza(stanza) if @handler
+      end 
+    end 
     
     ## 
     # Sends the Nokogiri::XML data (after converting to string) on the stream. It also appends the right "from" to be the component's JId if none has been mentionned. Eventually it displays this data for debugging purposes.
@@ -92,8 +90,7 @@ module Babylon
     ##
     # Sends a node on the "line".
     def send_node(node)
-      @last_stanza_sent = node
-      node["from"] = jid if !node.attributes["from"] && node.attributes["to"]
+      node["from"] ||= jid if node["to"]
       send_string(node.to_xml)
     end
     

data/lib/babylon/xmpp_parser.rb

@@ -63,8 +63,8 @@ module Babylon
         @callback.call(e)
       else
         # Adding the newly created element to the @elem that is being parsed, or, if no element is being parsed, then we set the @top and the @elem to be this newly created element.
-        # Room is the "highest" element to (it's parent is the <stream> element)
-        @elem = @elem ? @elem.add_child(e) : (@top = e)
+        # @top is the "highest" element to (it's parent is the <stream> element)
+        @elem = @elem ? @elem.add_child(e) : (@top = @doc.root.add_child(e))
       end
     end
 
@@ -74,6 +74,8 @@ module Babylon
       if @elem
         if @elem == @top
           @callback.call(@elem) 
+          # Remove the element from its content, since we're done with it!
+          @elem.unlink
           # And the current elem is the next sibling or the root
           @elem = @top = nil
         else
@@ -92,7 +94,7 @@ module Babylon
       (attrs.size / 2).times do |i|
         name, value = attrs[2 * i], attrs[2 * i + 1]
         if name =~ /xmlns/
-          node.add_namespace(name, value)
+          node.add_namespace(name.gsub("xmlns:", "").gsub("xmlns", ""), value)
         else
           node.set_attribute name, value
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: julien51-babylon
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors: 
 - julien Genestoux
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-23 00:00:00 -07:00
+date: 2009-03-25 00:00:00 -07:00
 default_executable: babylon
 dependencies: []