julien51-babylon 0.0.5 → 0.0.7

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 julien
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -9,7 +9,6 @@ This framework can use both an XMPP Component (XEP-0114) and an XMPP Client. How
 == FEATURES/PROBLEMS:
 
 * This hasn't been tested. 
-* Problems with quotes and double-quotes in text that are not handled correctly... I spent too many hours on this! Please help!
 
 == ROADMAP :
 
@@ -31,9 +30,9 @@ To create an Application with Babylon:
 
 3. Use the generator or write your own controllers : 
 
-    $> scripts/generate message echo:10:"//message[@type='chat']/body" subscribed:0:"//presence[@type='subscribe']"
+    $> script/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 
+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.rb 
 
 4. Write your application's code and views :
 
@@ -88,6 +87,8 @@ Compared to Rails, we are using accessors (and not @variables assigned in the co
 
 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 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.
+
 == REQUIREMENTS:
 
 Gems : Eventmachine, nokogiri, YAML
@@ -121,4 +122,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

metadata

@@ -1,76 +1,37 @@
 --- !ruby/object:Gem::Specification 
 name: julien51-babylon
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors: 
-- Julien Genestoux
-- Astro
+- julien Genestoux
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-02-13 00:00:00 -08:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: nokogiri
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: eventmachine
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-description: Babylon is a framework to create EventMachine based XMPP External Components in Ruby.
-email: babylon@notifixio.us
+date: 2009-03-18 00:00:00 -07:00
+default_executable: babylon
+dependencies: []
+
+description: 
+email: julien.genestoux@gmail.com
 executables: 
 - babylon
 extensions: []
 
-extra_rdoc_files: []
-
-files: 
+extra_rdoc_files: 
 - README.rdoc
-- lib/babylon.rb
-- lib/babylon/base/controller.rb
-- lib/babylon/base/view.rb
-- lib/babylon/component_connection.rb
-- lib/babylon/client_connection.rb
-- lib/babylon/router.rb
-- lib/babylon/runner.rb
-- lib/babylon/xmpp_connection.rb
+- LICENSE
+files: 
 - bin/babylon
-- spec
-- templates
-- templates/babylon
-- templates/babylon/app
-- templates/babylon/app/controllers/README.rdoc
-- templates/babylon/app/models/README.rdoc
-- templates/babylon/app/views/README.rdoc
-- templates/babylon/config
-- templates/babylon/config/routes.yaml
-- templates/babylon/config/config.yaml
-- templates/babylon/config/boot.rb
-- templates/babylon/scripts
-- templates/babylon/scripts/component
-- templates/babylon/scripts/generate
+- README.rdoc
+- LICENSE
 has_rdoc: true
-homepage: http://github.com/julien51/babylon/
+homepage: http://github.com/julien51/babylon
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -85,8 +46,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version 
       version: "0"
   version: 
-requirements: []
-
+requirements: 
+- eventmachine
+- yaml
+- fileutils
+- log4r
+- nokogiri
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 

data/lib/babylon.rb

@@ -1,25 +0,0 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-require 'eventmachine'
-require 'nokogiri'
-
-require 'babylon/xmpp_connection.rb'
-require 'babylon/component_connection.rb'
-require 'babylon/client_connection.rb'
-require 'babylon/router.rb'
-require 'babylon/runner.rb'
-require 'babylon/base/controller.rb'
-require 'babylon/base/view.rb'
-
-# Babylon is a XMPP Component Framework based on EventMachine. It uses the Nokogiri GEM, which is a Ruby wrapper for Libxml2.
-# It implements the MVC paradigm.
-# You can create your own application by running :
-#   $> babylon app_name
-# This will generate some folders and files for your application. Please see README for further instructions
-
-module Babylon
-  # 0.0.5 : Not suited for production, use at your own risks
-  VERSION = '0.0.5'
-end
-

data/lib/babylon/base/controller.rb

@@ -1,65 +0,0 @@
-module Babylon
-  module Base
-    
-    # Your application's controller should be descendant of this class.
-    
-    class Controller
-      
-      attr_accessor :stanza # Stanza received by the controller (Nokogiri::XML::Node)
-      
-      # Creates a new controller (you should not override this class) and assigns the stanza
-      def initialize(params = {})
-        params.each do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
-        @rendered = false
-      end
-      
-      # Performs the action and calls back the optional block argument : you should not override this function
-      def perform(action, &block)
-        @action_name = action
-        @block = block
-        self.send(@action_name)
-        self.render
-      end
-      
-      # Called by default after each action to "build" a XMPP stanza. By default, it will use the /controller_name/action.xml.builder
-      def render(options = nil)
-        return if @rendered # Avoid double rendering
-        
-        if options.nil? # default rendering
-          return render(:file => default_template_name)
-        elsif action_name = options[:action]
-          return render(:file => default_template_name(action_name.to_s))
-        end
-        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
-      end
-      
-      protected
-
-      # Used to transfer the assigned variables from the controller to the views
-      def hashed_variables
-        vars =  Hash.new
-         instance_variables.each do |var|
-          vars[var[1..-1]] = instance_variable_get(var)
-        end
-        return vars
-      end
-      
-      # Default template name used to build stanzas
-      def default_template_name(action_name = nil)
-        path = "#{action_name || @action_name}.xml.builder"
-        return path
-      end
-      
-      # Creates the view and "evaluates" it to build the XML for the stanza
-      def render_for_file(file)
-        view = Babylon::Base::View.new(file, hashed_variables)
-        @block.call(view.evaluate)
-      end
-    end
-  end
-end

data/lib/babylon/base/view.rb

@@ -1,50 +0,0 @@
-module Babylon
-  module Base
-    
-    ##
-    # Your application's views (stanzas) should be descendant of this class.
-    class View 
-      attr_reader :output 
-      
-      ##
-      # Instantiate a new view with the various varibales passed in assigns and the path of the template to render.
-      def initialize(path, assigns)
-        @assigns = assigns
-        @output = ""
-        @view_template = path
-      end
-      
-      ##
-      # "Loads" the view file, and uses the Nokogiri Builder to build the XML stanzas that will be sent.
-      def evaluate 
-        evaluate_assigns
-        view_content = File.read(@view_template)
-        xml = Nokogiri::XML::Builder.new do
-          instance_eval(view_content)
-        end
-        return xml.doc.root #we return the doc's root (to avoid the instruct)
-      end
-      
-      ##
-      # Evaluate the local assigns and pushes them to the view.
-      def evaluate_assigns
-        unless @assigns_added
-          assign_variables_from_controller
-          @assigns_added = true
-        end
-      end
-      
-      ##
-      # Assigns instance variables from the controller to the view.
-      def assign_variables_from_controller
-        @assigns.each do |key, value| 
-          instance_variable_set("@#{key}", value)
-          self.class.send(:define_method, key) do # Defining accessors
-            value
-          end
-        end
-      end
-      
-    end 
-  end 
-end

data/lib/babylon/client_connection.rb

@@ -1,147 +0,0 @@
-module Babylon
-  
-  ##
-  # ClientConnection is in charge of the XMPP connection for a Regular XMPP Client.
-  # So far, SASL Plain authenticationonly is supported
-  # Upon stanza reception, and depending on the status (connected... etc), this component will handle or forward the stanzas.
-  class ClientConnection < XmppConnection
-    require 'digest/sha1'
-    require 'base64'
-
-    attr_reader :binding_iq_id, :session_iq_id
-
-    ## 
-    # Returns true only if we're in connected state
-    def connected?
-      @state == :connected
-    end
-
-    ##
-    # Creates a new ClientConnection and waits for data in the stream
-    def initialize(params)
-      super(params)
-      @state = :wait_for_stream
-    end
-
-    ##
-    # Connection_completed is called when the connection (socket) has been established and is in charge of "building" the XML stream 
-    # to establish the XMPP connection itself.
-    # 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.config['host'],  '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_data(start_stream)
-    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)
-      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"] = stanza.at("starttls").namespaces.first.last
-            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'] = stanza.at("mechanisms").namespaces.first.last
-              auth.content = Base64::encode64([@config['jid'],@config['jid'].split("@").first,@config['password']].join("\000")).gsub(/\s/, '')
-              send(auth)
-              @state = :wait_for_success
-            end
-          end
-        end
-      
-      when :wait_for_success
-        if stanza.name == "success" # Yay! Success
-          @success = true
-          @state = :wait_for_stream
-          send_data @outstream.root.to_xml.split('<paste_content_here/>').first
-        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.config['resource'] 
-                    resource(@context.config['resource'] )
-                  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
-        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
-          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")
-          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)
-          @state = :connected
-        end
-        
-      when :wait_for_proceed
-        start_tls() # starting TLS
-        @state = :wait_for_stream
-        send_data @outstream.root.to_xml.split('<paste_content_here/>').first
-      end
-
-    end
-
-    ##
-    # Namespace of the client
-    def stream_namespace
-      "jabber:client"
-    end
-
-  end
-end

data/lib/babylon/component_connection.rb

@@ -1,76 +0,0 @@
-module Babylon
-  ##
-  # ComponentConnection is in charge of the XMPP connection itself.
-  # Upon stanza reception, and depending on the status (connected... etc), this component will handle or forward the stanzas.
-  class ComponentConnection < XmppConnection
-    require 'digest/sha1'
-    
-    ## 
-    # Returns true only if we're in connected state
-    def connected?
-      @state == :connected
-    end
-    
-    ##
-    # Creates a new ComponentConnection and waits for data in the stream
-    def initialize(*a)
-      super
-      @state = :wait_for_stream
-    end
-    
-    ##
-    # Connection_completed is called when the connection (socket) has been established and is in charge of "building" the XML stream 
-    # to establish the XMPP connection itself.
-    # 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' => "jabber:component:accept", 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.config['jid']}) do
-          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_data(@start_stream)
-    end
-
-    ##
-    # XMPP Component handshake as defined in XEP-0114:
-    # http://xmpp.org/extensions/xep-0114.html
-    def receive_stanza(stanza)
-      case @state
-      when :connected # Most frequent case
-          super # Can be dispatched
-          
-      when :wait_for_stream
-        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 + @config['password'])
-          handshake = Nokogiri::XML::Node.new("handshake", stanza.document)
-          handshake.content = hash
-          send(handshake)
-          @state = :wait_for_handshake
-        else
-          raise
-        end
-
-      when :wait_for_handshake
-        if stanza.name == "handshake"
-          # Awesome, we're now connected and authentified, let's tell the CentralRouter we're connecter
-          CentralRouter.connected(self)
-          @state = :connected
-        else
-          raise
-        end
-
-      end
-    end
-    
-    ##
-    # Namespace of the component
-    def stream_namespace
-      'jabber:component:accept'
-    end
-    
-  end
-end

data/lib/babylon/router.rb

@@ -1,95 +0,0 @@
-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}
-    def add_routes(routes)
-      routes.each do |name, params|
-        add_route(Route.new(name, params))
-      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)
-      @routes ||= []
-      @routes << route
-      @routes.sort! { |r1,r2|
-        r2.priority <=> r1.priority
-      }
-    end
-
-    # Look for the first martching route and calls the correspondong action for the corresponding controller.
-    # Sends the response on the XMPP stream/ 
-    def route(stanza)
-      return false if !@@connection
-      @routes ||= []
-      @routes.each { |route|
-        if route.accepts?(stanza)
-          # Here should happen the magic : call the controller
-          controller = route.controller.new({:stanza => stanza})
-          controller.perform(route.action) do |response|
-            # Response should be a Nokogiri::Node Object
-            @@connection.send(response)
-          end
-          return true
-        end
-      }
-      false
-    end
-
-    # Throw away all added routes from this router. Helpful for
-    # testing.
-    def purge_routes!
-      @routes = []
-    end
-  end
-
-  ##
-  # Main router where all dispatchers shall register.
-  module CentralRouter
-    extend Router
-  end
-
-  ##
-  # Route class which associate an XPATH match and a priority to a controller and an action
-  class Route
-
-    attr_reader :priority, :controller, :action
-    
-    ##
-    # Creates a new route
-    def initialize(name, params)
-      @priority   = params["priority"]
-      @xpath      = params["xpath"]
-      @controller = Kernel.const_get("#{params["controller"].capitalize}Controller")
-      @action     = params["action"]
-    end
-
-    ##
-    # Checks that the route matches the stanzas and calls the the action on the controller
-    def accepts?(stanza)
-      stanza.xpath(@xpath, stanza.namespaces).first ? self : false
-    end
-    
-  end
-  
-end

data/lib/babylon/runner.rb

@@ -1,42 +0,0 @@
-module Babylon
-  
-  ##
-  # Runner is in charge of running the application.
-  class Runner
-
-    ##
-    # 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
-    # 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)
-      
-      # Requiring all models
-      Dir.glob('app/models/*.rb').each do |f| 
-        require f 
-      end
-      
-      # Starting the EventMachine
-      EventMachine.epoll
-      EventMachine::run do
-        if config["application_type"] == "client"
-          Babylon::ClientConnection.connect(config) do |stanza|
-            CentralRouter.route stanza # Upon reception of new stanza, we Route them through the controller
-          end
-        else
-          Babylon::ComponentConnection.connect(config) do |stanza|
-            CentralRouter.route stanza # Upon reception of new stanza, we Route them through the controller
-          end
-        end
-        # 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
-    
-  end
-end

data/lib/babylon/xmpp_connection.rb

@@ -1,158 +0,0 @@
-module Babylon
-
-  ## 
-  # Connection Exception
-  class NotConnected < Exception; end
-
-  ##
-  # This class is in charge of handling the network connection to the XMPP server.
-  class XmppConnection < EventMachine::Connection
-
-    attr_reader :config
-    
-    ##
-    # Connects the XmppConnection to the right host with the right port. 
-    # It passes itself (as handler) and the configuration
-    def self.connect(config, &block)
-      EventMachine::connect config['host'], config['port'], self, config.merge({:callback => block})
-    end
-
-    ##
-    # Called when the connection is terminated and stops the event loop
-    def unbind()
-      EventMachine::stop_event_loop
-    end
-
-    ## 
-    # Instantiate the Handler (called internally by EventMachine) and attaches a new XmppParser
-    def initialize(config)
-      @config = config
-      super()
-      @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. Eventually it displays this data for debugging purposes
-    def receive_stanza(stanza)
-      # If not handled by subclass (for authentication)
-      @config[:callback].call(stanza) if @config[:callback]
-    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
-    def send(xml)
-      if !xml.attributes["from"]
-        xml["from"] = jid
-      end
-      puts "SENDING  #{xml}\n" if debug? # Very low level Logging
-      send_data "#{xml}"
-    end
-    
-    ##
-    # Memoizer for jid. The jid can actually be changed in subclasses (client will probbaly want to change it to include the resource) 
-    def jid
-      @jid ||= config['jid']
-    end
-
-    private
-
-    ## 
-    # receive_data is called when data is received. It is then passed to the parser. 
-    def receive_data(data)
-      puts "RECEIVED #{data}\n"  if debug? # Low level Logging 
-      @parser.parse data
-    end
-    
-    ## 
-    # Pretty self-explanatory ;)
-    def debug?
-      @config["debug"]
-    end
-  end
-
-  ##
-  # This is the XML SAX Parser that accepts "pushed" content
-  class XmppParser < Nokogiri::XML::SAX::Document
-    
-    ##
-    # Initialize the parser and adds the callback that will be called upen stanza completion
-    def initialize(&callback)
-      @callback = callback
-      super()
-      @parser = Nokogiri::XML::SAX::Parser.new(self)
-      @doc = nil
-      @elem = nil
-    end
-    
-    ##
-    # Parses the received data
-    def parse(data)
-      @parser.parse data
-    end
-
-    ## 
-    # Called when the document received in the stream is started
-    def start_document
-      @doc = Nokogiri::XML::Document.new
-    end
-    
-    ##
-    # Adds characters to the current element (being parsed)
-    def characters(string)
-      @elem.add_child(Nokogiri::XML::Text.new(string, @doc))
-    end
-
-    ##
-    # Instantiate a new current Element, adds the corresponding attributes and namespaces
-    # The new element is eventually added to a parent element (if present).
-    # If this element is the first element (the root of the document), then instead of adding it to a parent, we add it to the document itself. In this case, the current element will not be terminated, so we activate the callback immediately.
-    def start_element(qname, attributes = [])
-      e = Nokogiri::XML::Element.new(qname, @doc)
-      add_namespaces_and_attributes_to_node(attributes, e)
-      
-      # If we don't have any elem yet, we are at the root
-      @elem = @elem ? @elem.add_child(e) : (@root = e)
-      
-      if @elem.name == "stream:stream"
-        # Should be called only for stream:stream
-        @doc = Nokogiri::XML::Document.new
-        @root = @elem
-        @doc.root = @elem
-        @callback.call(@elem)
-      end
-    end
-
-    ##
-    # Terminates the current element and calls the callback
-    def end_element(name)
-      if @elem
-        if @elem.parent == @root
-          @callback.call(@elem) 
-          # And we also need to remove @elem from its tree
-          @elem.unlink 
-          # And the current elem is the root
-          @elem = @root 
-        else
-          @elem = @elem.parent 
-        end
-      end
-    end
-    
-    private
-    
-    ##
-    # Adds namespaces and attributes. Nokogiri passes them as a array of [name, value, name, value]...
-    def add_namespaces_and_attributes_to_node(attrs, node) 
-      (attrs.size / 2).times do |i|
-        name, value = attrs[2 * i], attrs[2 * i + 1]
-        if name =~ /xmlns/
-          node.add_namespace(name, value)
-        else
-          node.set_attribute name, value
-        end
-      end
-    end
-    
-  end
-
-end

data/templates/babylon/app/controllers/README.rdoc

@@ -1,13 +0,0 @@
-= Babylon::Base::Controller
-
-== Usage :
-
-Please see Babylon rdoc.
-
-== Example 
-
-    class MyController < Babylon::Base::Controller  
-        def my_action
-            // Do something great!
-        end
-    end

data/templates/babylon/app/models/README.rdoc

@@ -1 +0,0 @@
-You can define you class models here. It is totally ok to reuse your ActiveRecord from another application!

data/templates/babylon/app/views/README.rdoc

@@ -1,12 +0,0 @@
-= Babylon::Base::View
-
-== Usage
-
-Please see Babylon Rdoc. Put all the views related to controller MyController into app/views/my/...
-This file are Xml Builder Files (see Nokogiri Documentation for any doubt).
-
-== Example
-
-    self.message(:to => to, :from => from, :type => :chat) do
-        self.body(body) // Same as self.send(:body, body) (
-    end

data/templates/babylon/config/boot.rb

@@ -1,8 +0,0 @@
-require "rubygems"
-require "babylon"
-
-# Load the controllers
-Dir.glob(File.join(File.dirname(__FILE__), '../app/controllers/*_controller.rb')).each {|f| require f }
-
-# And start the App
-Babylon::Runner::run()

data/templates/babylon/config/config.yaml

@@ -1,29 +0,0 @@
-# This contains the global configuration of your component.
-# env:
-#    jid: your.component.jid
-#    password: your.component.password
-#    host: host on which the XMPP server is running
-#    port: port to which your component should connect
-#    debug: outputs the xmpp stanzas
-#    application_type: client | component (by default it is component and we strongly discourage any client application in production)
-
-development:
-    jid: component.server.com
-    password: password
-    host: localhost
-    port: 5278
-    debug: true 
-
-test:
-    jid: component.server.com
-    password: password
-    host: localhost
-    port: 5278
-    debug: false
-        
-production:
-    jid: component.server.com
-    password: password
-    host: localhost
-    port: 5278
-    debug: false

data/templates/babylon/config/routes.yaml

@@ -1,15 +0,0 @@
-# This determines the routing for your controllers
-# The macthing is based on XPATH
-
-# route_name:
-#   priority: if a stanza matches several XPath conditions, the one with the greater priority will be executed. If they have the same priority, one will be chose randomly, so choose your priority very carefully! It is a good practice to attribute a different priority to each of your routes, so that there is no conflict
-#   controller: name of the controller that should handle the stanza
-#   action: action to be called to handle the stanza
-#   xpath: used to macth the stanza
-
-# my_route_1:
-#     priority: 1
-#     controller: main
-#     xpath: "//message"
-#     action: echo
-

data/templates/babylon/scripts/component

@@ -1,2 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../config/boot'

data/templates/babylon/scripts/generate

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-
-## 
-# This is a generator that will build scaffold controller and add the corresponding routes
-#
-# == Usage
-#
-#   $> scripts/generate controller_name [action_name:priority;Xpath, ...]
-#
-# == Example
-#
-#   $> scripts/generate message echo:10:"//message/body" reverse:0:"//message"
-#
-# This will generate a an echo controller with 2 actions : echo and reverse. Echo will be called for stanza of type message witch a body than contains "echo", while reverse will be called for any other stanza of type message.
-
-
-# Create the views subdirectory
-Dir.mkdir "app/views/#{ARGV[0]}" if !File.exists?("app/views/#{ARGV[0]}")
-# CReate the controller file and write the first lines
-controller_file = File.open("app/controllers/#{ARGV[0]}_controller.rb", "w+")
-route_file = File.open("config/routes.yaml", "a")
-controller_file.puts "class #{ARGV[0].capitalize}Controller < Babylon::Base::Controller"
-controller_file.puts ""
-ARGV[1..-1].each do |action|
-  action_name, priority, xpath = action.split(":")
-  # Add the action to the controller
-  controller_file.puts ""
-  controller_file.puts "  def #{action_name}"
-  controller_file.puts "    # Called when the stanza matches #{xpath}. Priority #{priority}"
-  controller_file.puts "    "
-  controller_file.puts "  end"
-  # Create the file views
-  view_file = File.open("app/views/#{ARGV[0]}/#{action_name}.xml.builder", "w+")
-  view_file.puts "self.message(:to => to, :from => from, :type => :chat) do"
-  view_file.puts "  self.body(content) # Same as self.send(:body, body) "
-  view_file.puts "end"
-  view_file.close
-  # And now add the route (we must be careful and not delete other routes)
-  route_file.puts ""
-  route_file.puts "#{ARGV[0]}_#{action_name}_route:"
-  route_file.puts "   priority: #{priority}"
-  route_file.puts "   controller: #{ARGV[0]}"
-  route_file.puts "   xpath: #{xpath}"
-  route_file.puts "   action: #{action_name}"
-end
-controller_file.puts "end"
-