julien51-babylon 0.0.14 → 0.1.0

data/README.rdoc

@@ -4,24 +4,20 @@
 
 Babylon is a framework to build XMPP Applications in Ruby. The framework uses EventMachine to handle network connections.
 
-This framework can use both an XMPP Component (XEP-0114) and an XMPP Client (and XMPP Servers should come soone). However, we strongly discourage any production application using a regular client.
+This framework can use both an XMPP Component (XEP-0114) and an XMPP Client (and XMPP Servers should come soon). However, we strongly discourage any production application using a regular client.
 
 == FEATURES/PROBLEMS:
 
-Please report/request them at the Lighthouse : http://babylon.lighthouseapp.com/projects/27641-babylon/overview
+Please link "report/request here.":http://github.com/julien51/babylon/issues
 
 The current version is a good candidate for version 0.1. We will probably not add any important features before that release, but we need some help with the tests and documentation.
 
 == ROADMAP :
 
-- Improve the Client Connection to support other authentication than PLAIN SASL
 - Implement the ServerConnection for S2S
-- Implement "auto-responding" features for disco-info... etc
-- Use a better generator (the next version of Nokogiri should fix that)
-- Implement "background" running when in production (and adjust log level)
+- Implement templates for disco-info... and common XEPs
 - Delete route priorities? And rely on the order only? (As Rails does)
 - Review doc
-- Write more spec
 - Write tests
 - Evangelize!
 
@@ -29,8 +25,10 @@ You can help with at least one of these points, don't turn your back on Babylon!
 
 == DOCUMENTATION :
 
-You can find it on our Rubyforge page : http://babylon.rubyforge.org/
-Please note that the documentation is probably incomplete... so if you have any problems with something that is not clear enough to you, feel free to send us questions and do not hesitate to fork the project to add your own documentation. We will be more than happy to help you help us!
+You can find it on our "Rubyforge page":http://babylon.rubyforge.org/
+Feel free to fork the "github":http://github.com/julien51/babylon/tree/master repo and add some documentation if you think anything is missing. 
+
+__You can't be a bad coder, a bad tester and a bad documenter at the same time ;)__
 
 == SYNOPSIS :
 
@@ -41,19 +39,19 @@ You can build applications directly with Babylon, or you can use the Babylon::Cl
 1. Install the gem
 2. The app contains a generator that will "build" a scaffold for your application. 
     
-    $> babylon application <myapp>
+    $> babylon application __myapp__
 
 3. Use the generator or write your own controllers : 
 
-    $> babylon controller messages echo:10://message[@type='chat']/body,subscribed:0://presence[@type='subscribe']
+    $> babylon controller __messages__ __echo__:__10__:__//stream:message[@type='chat']/body__,__subscribed__:__0__:__//stream:presence[@type='subscribe']__
 
-This will generate a "MessagesController" class with 2 methods : echo and subscribed. 
+This will generate a __MessagesController__ class with 2 methods : __echo__ and __subscribed__. 
  - "echo" will be called when the component receives message stanzas of type 'chat', 
  - "subscribed" will be called for presence stanzas of type 'subscribe'. 
 10 and 0 are the priority : useful when a stanza matches 2 XPath.  
 
-Each of these actions will be called with stanza objects. You have to define your own objects in stanzas/echo.rb and stanzas/subscribed.rb
-By defining them, you can choose which elements and attributes you want to have access to. These attributes will be populated upon instantiation of the Stanza objects.
+Each of these actions will be called with stanza objects. You have to define your own objects in __stanzas/echo.rb__ and __stanzas/subscribed.rb__
+By implementing them, you can choose which elements and attributes you want to have access to. These attributes will be populated upon instantiation of the Stanza objects.
 
 This will also generate 2 'views' used to build your responses stanzas. 
 
@@ -61,7 +59,7 @@ And finally, this will write 2 routes in the config/routes.rb
 
 4. Customize your controllers, stanzas and views!
 
-5. Make sure that the XMPP settings are correct in config/config.yaml. !!! You need to have a Jabber Component, regular clients will NOT work!!!
+5. Make sure that the XMPP settings are correct in config/config.yaml. 
 
 6. And finally start the component :
     
@@ -85,7 +83,7 @@ Babylon's edge versions are located at Github : http://github.com/julien51/babyl
 
 == REQUIREMENTS :
 
-Gems : Eventmachine, nokogiri, YAML, log4r, sax-machine, templater, daemons
+Gems : Eventmachine, nokogiri (please, use build from the guthub repo, since 1.2.3 is not supported by Babylon), YAML, log4r, sax-machine, templater, daemons
 
 == LICENSE:
 

data/Rakefile

@@ -82,10 +82,8 @@ begin
   Spec::Rake::SpecTask.new('spec') do |spec|
     spec.spec_files = FileList['spec/**/*.rb']
     spec.verbose = true
-    spec.warning = true
+    spec.warning = false
     spec.rcov = true
-    spec.rcov_opts = []
-    spec.rcov_opts = ['--exclude', 'spec']
   end
 rescue LoadError
   task :spec do

data/lib/babylon.rb

@@ -39,20 +39,35 @@ module Babylon
     @@env
   end
   
+  ##
+  # Sets up the router
+  def self.router=(router)
+    @@router = router
+  end
+  
+  ##
+  # Retruns the router
+  def self.router
+    unless self.class_variable_defined?("@@router")
+      @@router = nil
+    end
+    @@router
+  end
+  
   ##
   # Caches the view files to improve performance.  
   def self.cache_views
-    @@cached_views= {}
+    @@views= {}
     Dir.glob('app/views/*/*').each do |f|
-      @@cached_views[f] = File.read(f)
+      @@views[f] = File.read(f)
     end        
   end
   
-  def self.cached_views
-    unless self.class_variable_defined?("@@cached_views")
-      @@cached_views= {}
+  def self.views
+    unless self.class_variable_defined?("@@views")
+      @@views= {}
     end
-    @@cached_views
+    @@views
   end
 
   ##
@@ -77,5 +92,21 @@ module Babylon
     @@config
   end
   
+  ##
+  # Decodes XML special characters.
+  def self.decode_xml(str)
+    entities = {
+      'lt'    => '<',
+      'gt'    => '>',
+      '#38'   => '&',
+      'amp'   => '&',
+      'quot'  => '"',
+      '#13'   => "\r",
+    } 
+    entities.keys.inject(str) { |string, key|
+      string.gsub(/&#{key};/, entities[key])
+    } 
+  end
+  
 end
 

data/lib/babylon/base/controller.rb

@@ -11,14 +11,13 @@ module Babylon
       # Creates a new controller (you should not override this class) and assigns the stanza as well as any other value of the hash to instances named after the keys of the hash.
       def initialize(stanza = nil)
         @stanza = stanza
-        @rendered = false
+        @view = nil
       end
       
       ##
       # Performs the action and calls back the optional block argument : you should not override this function
-      def perform(action, &block)
+      def perform(action)
         @action_name = action
-        @block = block
         begin
           self.send(@action_name)
         rescue
@@ -31,12 +30,12 @@ module Babylon
       # Returns the list of variables assigned during the action.
       def assigns
         vars = Hash.new
-         instance_variables.each do |var|
-           if !["@rendered", "@action_name", "@block"].include? var
-             vars[var[1..-1]] = instance_variable_get(var)
-           end
+        instance_variables.each do |var|
+          if !["@view", "@action_name", "@block"].include? var
+            vars[var[1..-1]] = instance_variable_get(var)
+          end
         end
-        return vars
+        vars
       end
       
       ##
@@ -45,44 +44,53 @@ module Babylon
       #   - :file : render a specific file (can be in a different controller)
       #   - :action : render another action of the current controller
       #   - :nothing : doesn't render anything
-      def render(options = nil)
-        return if @rendered # Avoid double rendering
+      def render(options = {}) 
+        return if @view and !options[:force] # Avoid double rendering, if we have already attached a view
         
-        if options.nil? # default rendering
-          render(:file => default_template_name)
+        if options == {} # default rendering
+          result = render(:file => default_template_name)
         elsif options[:file]
           file = options[:file]
-          if file.include?('/')
-            render_for_file("app/views/#{file}.xml.builder")
+          if file =~ /^\// # Render from view root
+            result = render_for_file(File.join("app", "views", "#{file}.xml.builder"))
           else
-            render_for_file(view_path(file)) 
+            result = render_for_file(view_path(file)) 
           end
         elsif action_name = options[:action]
-          render(:file => default_template_name(action_name.to_s))
+          result = render(:file => default_template_name(action_name.to_s))
         elsif options[:nothing]
-          # Then we don't do anything.
+          @view = Babylon::Base::View.new()
         end
-        
-        # And finally, we set up rendered to be true 
-        @rendered = true
+      end
+      
+      ##
+      # Actually evaluates the view
+      def evaluate
+        @view.evaluate if @view
       end
       
       protected
       
+      ##
+      # Builds the view path.
       def view_path(file_name)
-        File.join("app/views", "#{self.class.name.gsub("Controller","").downcase}", file_name)
+        File.join("app", "views", "#{self.class.name.gsub("Controller","").downcase}", file_name)
       end
       
+      ##
       # Default template name used to build stanzas
       def default_template_name(action_name = nil)
-        return "#{action_name || @action_name}.xml.builder"
+        "#{action_name || @action_name}.xml.builder"
       end
       
+      ##
       # Creates the view and "evaluates" it to build the XML for the stanza
       def render_for_file(file)
-        @block.call(Babylon::Base::View.new(file, assigns).evaluate) if @block
-        Babylon.logger.info("RENDERED : #{file}")
+        Babylon.logger.info("RENDERING : #{file}")
+        @view = Babylon::Base::View.new(file, assigns)
+        Babylon.logger.info(" ")
       end
+      
     end
   end
 end

data/lib/babylon/base/stanza.rb

@@ -13,14 +13,12 @@ module Babylon
     # element :message, :value => :id, :as => :stanza_id 
     # element :message, :value => :type, :as => :stanza_type 
     # element :message, :value => :"xml:lang", :as => :lang 
-    
+    #
     class Stanza
-      
       include SAXMachine
       
       def initialize(xml = nil)
-        @xml = xml
-        parse("#{xml}")
+        parse(xml.to_s)
       end
     end
   end

data/lib/babylon/base/view.rb

@@ -1,34 +1,34 @@
 module Babylon
   module Base
     
+    class ViewFileNotFound < Errno::ENOENT; end
+    
     ##
     # Your application's views (stanzas) should be descendant of this class.
     class View 
-      attr_reader :output, :view_template
+      attr_reader :view_template 
       
       ##
       # Instantiate a new view with the various varibales passed in assigns and the path of the template to render.
-      def initialize(path, assigns)
-        @output = ""
-        @view_template = path
+      def initialize(path = "", assigns = {}) 
+        @view_template = path 
+        
         assigns.each do |key, value| 
-          instance_variable_set("@#{key}", value)
-          self.class.send(:define_method, key) do # Defining accessors
-            value
-          end
-        end
-      end
+          instance_variable_set(:"@#{key}", value) 
+        end 
+      end 
       
-      ##
-      # "Loads" the view file, and uses the Nokogiri Builder to build the XML stanzas that will be sent.
-      def evaluate
-        str = (Babylon.cached_views && Babylon.cached_views[@view_template]) ? Babylon.cached_views[@view_template] : File.read(@view_template)
-        xml = Nokogiri::XML::Builder.new do
-          instance_eval(str)
+      ## 
+      # "Loads" the view file, and uses the Nokogiri Builder to build the XML stanzas that will be sent. 
+      def evaluate 
+        return if @view_template == ""
+        raise ViewFileNotFound unless Babylon.views[@view_template] 
+        builder = Nokogiri::XML::Builder.new 
+        builder.stream do |xml|
+          eval(Babylon.views[@view_template]) 
         end
-        return xml.doc.children #we return the doc's children (to avoid the instruct)
-      end
-      
+        builder.doc.root.children # we output the document built 
+      end 
     end 
   end 
 end

data/lib/babylon/client_connection.rb

@@ -25,35 +25,47 @@ module Babylon
       return super(params, handler) if params["host"] && params["port"]
 
       begin
-        begin
-          srv = []
-          Resolv::DNS.open { |dns|
-            # If ruby version is too old and SRV is unknown, this will raise a NameError
-            # which is caught below
-            host_from_jid = params["jid"].split("/").first.split("@").last
-            Babylon.logger.debug("RESOLVING: _xmpp-client._tcp.#{host_from_jid} (SRV)")
-            srv = dns.getresources("_xmpp-client._tcp.#{host_from_jid}", Resolv::DNS::Resource::IN::SRV)
-          }
-          # Sort SRV records: lowest priority first, highest weight first
-          srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }
-          # And now, for each record, let's try to connect.
-          srv.each { |record|
-            begin
-              params["host"] = record.target.to_s
-              params["port"] = Integer(record.port)
-              super(params, handler)
-              # Success
-              break
-            rescue SocketError, Errno::ECONNREFUSED
-              # Try next SRV record
-            end
-          }
-        rescue NameError
-          Babylon.logger.debug "Resolv::DNS does not support SRV records. Please upgrade to ruby-1.8.3 or later! \n#{$!} : #{$!.backtrace.join("\n")}"
-        end
+        srv = []
+        Resolv::DNS.open { |dns|
+          # If ruby version is too old and SRV is unknown, this will raise a NameError
+          # which is caught below
+          host_from_jid = params["jid"].split("/").first.split("@").last
+          Babylon.logger.debug("RESOLVING: _xmpp-client._tcp.#{host_from_jid} (SRV)")
+          srv = dns.getresources("_xmpp-client._tcp.#{host_from_jid}", Resolv::DNS::Resource::IN::SRV)
+        }
+        # Sort SRV records: lowest priority first, highest weight first
+        srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }
+        # And now, for each record, let's try to connect.
+        srv.each { |record|
+          begin
+            params["host"] = record.target.to_s
+            params["port"] = Integer(record.port)
+            super(params, handler)
+            # Success
+            break
+          rescue NotConnected
+            # Try next SRV record
+          end
+        }
+      rescue NameError
+        Babylon.logger.debug "Resolv::DNS does not support SRV records. Please upgrade to ruby-1.8.3 or later! \n#{$!} : #{$!.backtrace.join("\n")}"
       end
     end
 
+    ##
+    # Builds the stream stanza for this client
+    def stream_stanza
+      doc = Nokogiri::XML::Document.new
+      stream = Nokogiri::XML::Node.new("stream", doc)
+      doc.add_child(stream)
+      stream.add_namespace(nil, stream_namespace())
+      stream.add_namespace("stream", "http://etherx.jabber.org/streams")
+      stream["to"] = jid.split("/").first.split("@").last
+      stream["version"] = "1.0"
+      paste_content_here = Nokogiri::XML::Node.new("paste_content_here", doc)
+      stream.add_child(paste_content_here)
+      doc.to_xml.split('<stream:paste_content_here/>').first
+    end
 
     ##
     # Connection_completed is called when the connection (socket) has been established and is in charge of "building" the XML stream 
@@ -61,46 +73,45 @@ module Babylon
     # We use a "tweak" here to send only the starting tag of stream:stream
     def connection_completed
       super
-      builder = Nokogiri::XML::Builder.new do
-        self.send('stream:stream', {'xmlns' => @context.stream_namespace(), 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.jid.split("/").first.split("@").last,  'version' => '1.0'}) do
-          paste_content_here #  The stream:stream element should be cut here ;)
-        end
-      end
-      @outstream = builder.doc
-      start_stream, stop_stream = builder.to_xml.split('<paste_content_here/>')
-      send_xml(start_stream)
+      send_xml(stream_stanza)
     end
 
     ##
     # 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)
-      begin
         case @state
         when :connected
           super # Can be dispatched
 
+        when :wait_for_stream_authenticated
+          if stanza.name == "stream:stream" && stanza.attributes['id']
+            @state = :wait_for_bind
+          end
+
         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
+            @state = :wait_for_auth_mechanisms
           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_xml(starttls)
+              doc = Nokogiri::XML::Document.new
+              starttls = Nokogiri::XML::Node.new("starttls", doc)
+              doc.add_child(starttls)
+              starttls.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-tls")
+              send_xml(starttls.to_s)
               @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)
+              if stanza.at("mechanisms").children.map() { |m| m.text }.include? "PLAIN"
+                doc = Nokogiri::XML::Document.new
+                auth = Nokogiri::XML::Node.new("auth", doc)
+                doc.add_child(auth)
                 auth['mechanism'] = "PLAIN"
-                auth['xmlns'] = "urn:ietf:params:xml:ns:xmpp-sasl"
+                auth.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-sasl")
                 auth.content = Base64::encode64([jid, jid.split("@").first, @password].join("\000")).gsub(/\s/, '')
-                send_xml(auth)
+                send_xml(auth.to_s)
                 @state = :wait_for_success
               end
             end
@@ -108,10 +119,9 @@ module Babylon
 
         when :wait_for_success
           if stanza.name == "success" # Yay! Success
-            @success = true
-            @state = :wait_for_stream
+            @state = :wait_for_stream_authenticated
             @parser.reset
-            send_xml @outstream.root.to_xml.split('<paste_content_here/>').first
+            send_xml(stream_stanza)
           elsif stanza.name == "failure"
             if stanza.at("bad-auth") || stanza.at("not-authorized")
               raise AuthenticationError
@@ -124,47 +134,53 @@ module Babylon
         when :wait_for_bind
           if stanza.name == "stream:features"
             if stanza.at("bind")
+              doc = Nokogiri::XML::Document.new
               # 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
+              iq = Nokogiri::XML::Node.new("iq", doc)
+              doc.add_child(iq)
+              iq["type"] = "set"
+              iq["id"] = binding_iq_id.to_s
+              bind = Nokogiri::XML::Node.new("bind", doc)
+              bind.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-bind")
+              iq.add_child(bind)
+              resource = Nokogiri::XML::Node.new("resource", doc)
+              if jid.split("/").size == 2 
+                resource.content = (@jid.split("/").last)
+              else
+                resource.content = "babylon_client_#{binding_iq_id}"
               end
-              iq = @outstream.add_child(builder.doc.root)
-              send_xml(iq)
+              bind.add_child(resource)
+              send_xml(iq.to_s)
               @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
+          if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  binding_iq_id
+            if stanza.at("jid")
+              @jid = stanza.at("jid").text
             end
+            # And now, we must initiate the session
+            @session_iq_id = Integer(rand(10000))
+            doc = Nokogiri::XML::Document.new
+            iq = Nokogiri::XML::Node.new("iq", doc)
+            doc.add_child(iq)
+            iq["type"] = "set"
+            iq["id"] = session_iq_id.to_s
+            session = Nokogiri::XML::Node.new("session", doc)
+            session.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-session")
+            iq.add_child(session)
+            send_xml(iq.to_s)
+            @state = :wait_for_confirmed_session
           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")
-            end
-          end
-          iq = @outstream.add_child(builder.doc.root)
-          send_xml(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")
+          if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) == session_iq_id
             # And now, send a presence!
-            presence = Nokogiri::XML::Node.new("presence", @outstream)
-            send_xml(presence)
+            doc = Nokogiri::XML::Document.new
+            presence = Nokogiri::XML::Node.new("presence", doc)
+            send_xml(presence.to_s)
             begin
               @handler.on_connected(self) if @handler and @handler.respond_to?("on_connected")
             rescue
@@ -177,11 +193,8 @@ module Babylon
           start_tls() # starting TLS
           @state = :wait_for_stream
           @parser.reset
-          send_xml @outstream.root.to_xml.split('<paste_content_here/>').first
+          send_xml stream_stanza
         end
-      rescue
-        Babylon.logger.error("#{$!}:\n#{$!.backtrace.join("\n")}")
-      end
     end
 
     ##