julien51-babylon 0.0.3 → 0.0.4

data/README.rdoc

@@ -21,38 +21,64 @@ Babylon is a framework to EventMachine based XMPP External Components in Ruby.
     
     $> babylon myapp
 
-3. Write your own "controllers"
+3. Use the generator or write your own controllers : 
+
+    $> scripts/generate message echo:10:"//message[@type='chat']/body" subscribed:0:"//presence[@type='subscribe']"
+
+This will generate a "MessageController" class with 2 methods : echo and subscribed. "echo" will be called when the component receives message stanzas of type 'chat',  while "subscribed" will be called for presence stanzas of type 'subscribe'. 10 and 0 are the priority : useful when a stanza matches 2 XPath.  Also, try to put high priorities to the "most frequent" stanzas to improve your component's performance. This will also generate 2 'views' used to build your stanzas. And finally, this will write 2 routes in the config/routes.yaml 
+
+4. Write your application's code and views :
 
 /app/controllers/message_controller.rb 
 
-    class MessageController < Babylon::Base::Controller  
-      # Each controller is initiated with the stanza.(similar to params in rails actions)
+    class MessageController < Babylon::Base::Controller
 
       def echo
-        # We do stuff here
+        extract_to_and_from
+        body = @stanza.xpath("//message/body").first
+        @resp = body.text.reverse
+      end
+
+      def subscribed
+        extract_to_and_from
+        @ack = "Thanks for following me!"
+      end
+
+      protected
+
+      def extract_to_and_from
+        @from = @stanza.attributes["to"].text
         @to = @stanza.attributes["from"].text
-        @from = @stanza.attributes["from"].text
-        @response = @stanza.elements["//body"].text
-        # By default, this would "render" the echo.xml.builder
       end
+
     end
+    
 
-4. Add the corresponding views (used to generate the messages). Babylon uses the same file conventions as Rails : a subdirectory for each controller, and one file per action :
+5. Implement the corresponding views (used to generate the messages). Babylon uses the same file conventions as Rails : a subdirectory for each controller, and one file per action :
 Compared to Rails, we are using accessors (and not @variables assigned in the controller). 
 
 /app/views/message/echo.xml.builder 
 
     self.message(:to => to, :from => from, :type => :chat) do
-        self.body(response)
+        self.body(resp)
+    end
+
+/app/views/message/subscribed.xml.builder
+
+    self.message(:to => to, :from => from, :type => :chat) do
+      self.body(ack) # Same as self.send(:body, body) 
     end
 
-5. And finally start the component :
+6. Make sure that the XMPP settings are correct in config/config.yaml. !!! You need to have a Jabber Component, regular clients will NOT work!!!
+
+
+7. And finally start the component :
     
     script/component
 
 == ADDITIONAL INFORMATION
 
-This code hasn't been tested at all! It's just a proof of concept. Feel free to pull, branch, improve {code|specs|tests|docs} and we will merge it!
+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!
 
 == REQUIREMENTS:
 

data/lib/babylon.rb

@@ -18,7 +18,7 @@ require 'babylon/base/view'
 # This will generate some folders and files for your application. Please see README for further instructions
 
 module Babylon
-  # 0.0.3 : Not suited for production, use at your own risks
-  VERSION = '0.0.3'
+  # 0.0.4 : Not suited for production, use at your own risks
+  VERSION = '0.0.4'
 end
 

data/lib/babylon/base/controller.rb

@@ -9,7 +9,9 @@ module Babylon
       
       # Creates a new controller (you should not override this class) and assigns the stanza
       def initialize(params = {})
-        @stanza = params[:stanza]
+        params.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
         @rendered = false
       end
       
@@ -30,7 +32,7 @@ module Babylon
         elsif action_name = options[:action]
           return render(:file => default_template_name(action_name.to_s))
         end
-        render_for_file(options[:file]) 
+        render_for_file(File.join("app/views", "#{self.class.name.gsub("Controller","").downcase}", options[:file])) 
         
         # And finally, we set up rendered to be true 
         @rendered = true
@@ -49,7 +51,8 @@ module Babylon
       
       # Default template name used to build stanzas
       def default_template_name(action_name = nil)
-        "app/views/#{self.class.name.gsub("Controller","").downcase}/#{action_name || @action_name}.xml.builder"
+        path = "#{action_name || @action_name}.xml.builder"
+        return path
       end
       
       # Creates the view and "evaluates" it to build the XML for the stanza

data/lib/babylon/base/view.rb

@@ -22,7 +22,7 @@ module Babylon
         xml = Nokogiri::XML::Builder.new do
           instance_eval(view_content)
         end
-        return xml.doc.root.to_xml #we return the doc's root (to avoid the instruct)
+        return xml.doc.root #we return the doc's root (to avoid the instruct)
       end
       
       ##

data/lib/babylon/component_connection.rb

@@ -33,9 +33,8 @@ module Babylon
 
       when :wait_for_handshake
         if stanza.name == "handshake"
-          # Awesome, we're now connected and authentified, let's
-          # callback the controllers to tell them we're connected!
-          # TODO
+          # Awesome, we're now connected and authentified, let's tell the CentralRouter we're connecter
+          CentralRouter.connected(self)
           @state = :connected
         else
           raise

data/lib/babylon/router.rb

@@ -4,6 +4,8 @@ module Babylon
   # The router is in charge of sending the right stanzas to the right controllers based on user defined Routes.
   module Router
     
+    @@connection = nil
+    
     ##
     # Add several routes to the router
     # Routes should be of form {name => params}
@@ -13,6 +15,18 @@ module Babylon
       end
     end
     
+    ##
+    # Connected is called by the XmppConnection to indicate that the XMPP connection has been established
+    def connected(connection)
+      @@connection = connection
+    end
+    
+    ## 
+    # Accessor for @@connection
+    def connection
+      @@connection
+    end
+    
     ##
     # Insert a route and makes sure that the routes are sorted
     def add_route(route)
@@ -25,14 +39,16 @@ module Babylon
 
     # Look for the first martching route and calls the correspondong action for the corresponding controller.
     # Sends the response on the XMPP stream/ 
-    def route(connection, stanza)
+    def route(stanza)
+      return false if !@@connection
       @routes ||= []
       @routes.each { |route|
-        if route.accepts?(connection, stanza)
+        if route.accepts?(stanza)
           # Here should happen the magic : call the controller
           controller = route.controller.new({:stanza => stanza})
           controller.perform(route.action) do |response|
-            connection.send(response)
+            # Response should be a Nokogiri::Node Object
+            @@connection.send(response)
           end
           return true
         end
@@ -70,7 +86,7 @@ module Babylon
 
     ##
     # Checks that the route matches the stanzas and calls the the action on the controller
-    def accepts?(connection, stanza)
+    def accepts?(stanza)
       stanza.xpath(@xpath, stanza.namespaces).first ? self : false
     end
     

data/lib/babylon/runner.rb

@@ -8,9 +8,10 @@ module Babylon
     # When run is called, it loads the configuration, the routes and add them into the router
     # It then loads the models.
     # Finally it starts the EventMachine and connect the ComponentConnection
-    def self.run(env = "development")
-      config = YAML::load(File.new('config/config.yaml'))[env]
-      routes = YAML::load(File.new('config/routes.yaml')) || []      
+    # You can pass an additional block that will be called upon launching, when the eventmachine has been started.
+    def self.run(env = "development", &callback) 
+      config = YAML::load(File.new('config/config.yaml'))[env] 
+      routes = YAML::load(File.new('config/routes.yaml')) || [] 
       
       # Adding Routes
       CentralRouter.add_routes(routes)
@@ -24,6 +25,9 @@ module Babylon
       EventMachine.epoll
       EventMachine::run do
         Babylon::ComponentConnection.connect(config)
+        
+        # And finally, let's allow the application to do all it wants to do after we started the EventMachine!
+        callback.call if callback
       end
     end
     

data/lib/babylon/xmpp_connection.rb

@@ -36,7 +36,7 @@ module Babylon
     def receive_stanza(stanza)
       puts "<< #{stanza}\n"  if debug? # Low level Logging 
       # If not handled by subclass (for authentication)
-      CentralRouter.route self, stanza
+      CentralRouter.route stanza
     end
 
     ##
@@ -54,10 +54,13 @@ module Babylon
     end
     
     ## 
-    # Sends data (string) on the stream. Eventually it displays this data for debugging purposes
+    # 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
     def send(xml)
+      if !xml.attributes["from"]
+        xml["from"] = config['jid']
+      end
       puts ">> #{xml}\n" if debug? # Very low level Logging
-      send_data xml.to_s
+      send_data "#{xml}"
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: julien51-babylon
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Julien Genestoux