julien51-babylon 0.0.7 → 0.0.8

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "babylon"
+    gem.summary = %Q{Babylon is a framework to create EventMachine based XMPP External Components in Ruby.}
+    gem.email = "julien.genestoux@gmail.com"
+    gem.homepage = "http://github.com/julien51/babylon"
+    gem.authors = ["julien Genestoux"]
+    gem.requirements = ["eventmachine", "yaml", "fileutils", "log4r", "nokogiri"]
+    gem.executables = "babylon"
+    gem.files = ["bin/babylon", "lib/babylon.rb", "lib/babylon/base/controller.rb", "lib/babylon/base/view.rb", "lib/babylon/client_connection.rb", "lib/babylon/component_connection.rb", "lib/babylon/router/dsl.rb", "lib/babylon/router.rb", "lib/babylon/runner.rb", "lib/babylon/xmpp_connection.rb", "lib/babylon/xpath_helper.rb", "LICENSE", "Rakefile", "README.rdoc", "templates/babylon/app/controllers/README.rdoc", "templates/babylon/app/models/README.rdoc", "templates/babylon/app/views/README.rdoc", "templates/babylon/config/boot.rb", "templates/babylon/config/config.yaml", "templates/babylon/config/dependencies.rb", "templates/babylon/config/routes.rb", "templates/babylon/config/initializers/README.rdoc"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'babylon'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :install => :build
+
+task :default => :test

data/bin/babylon

@@ -4,9 +4,11 @@
 # This will generate the right hierarchy for a Babylon App
 # First, let's create the app directoryn based in ARGV[0]
 
+require 'fileutils'
+
 if ARGV[0]
   puts "Creating app '#{ARGV[0]}' in #{Dir.pwd}..."
   FileUtils.cp_r "#{File.dirname(__FILE__)}/../templates/babylon", "#{Dir.pwd}/#{ARGV[0]}"
 else
-  puts "Syntax : $> babylon app_name "
+  puts "Usage: #{$0} <app_name>"
 end

data/lib/babylon.rb

@@ -0,0 +1,82 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'eventmachine'
+require 'log4r'
+require 'nokogiri'
+require 'yaml'
+require 'fileutils'
+
+require 'babylon/xmpp_connection'
+require 'babylon/component_connection'
+require 'babylon/client_connection'
+require 'babylon/router'
+require 'babylon/runner'
+require "babylon/xpath_helper"
+require 'babylon/base/controller'
+require 'babylon/base/view'
+
+# 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
+
+  def self.environment=(_env)
+    @@env = _env
+  end
+
+  def self.environment
+    unless self.class_variable_defined?("@@env")
+      @@env = "development"
+    end
+    @@env
+  end
+  
+  ##
+  # Caches the view files to improve performance.  
+  def self.cache_views
+    @@cached_views= {}
+    Dir.glob('app/views/*/*').each do |f|
+      @@cached_views[f] = File.read(f)
+    end        
+  end
+  
+  def self.cached_views
+    unless self.class_variable_defined?("@@cached_views")
+      @@cached_views= {}
+    end
+    @@cached_views
+  end
+
+  ##
+  # Returns a shared logger for this component.
+  def self.logger
+    unless self.class_variable_defined?("@@logger")
+      @@logger = Log4r::Logger.new("BABYLON")
+      @@logger.add(Log4r::Outputter.stderr)
+    end
+    @@logger
+  end
+
+  ##
+  # Set the configuration for this component.
+  def self.config=(conf)
+    @@config = conf
+  end
+
+  ##
+  # Return the configuration for this component.
+  def self.config
+    @@config
+  end
+
+  ##
+  # Authentication Error (wrong password/jid combination). Used for Clients and Components
+  class AuthenticationError < Exception 
+  end
+
+end
+

data/lib/babylon/base/controller.rb

@@ -0,0 +1,76 @@
+module Babylon
+  module Base
+    
+    ##
+    # Your application's controller should be descendant of this class.
+    class Controller
+      
+      attr_accessor :stanza, :rendered, :action_name # Stanza received by the controller (Nokogiri::XML::Node)
+      
+      ##
+      # 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(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
+        begin
+          self.send(@action_name)
+        rescue
+          Babylon.logger.error("#{$!}:\n#{$!.backtrace.join("\n")}")
+        end
+        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 options[:file]
+          render_for_file(view_path(options[:file])) 
+        elsif action_name = options[:action]
+          return render(:file => default_template_name(action_name.to_s))
+        end
+        
+        # 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
+      
+      def view_path(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"
+      end
+      
+      # Creates the view and "evaluates" it to build the XML for the stanza
+      def render_for_file(file)
+        Babylon.logger.info("RENDERING : #{file}")
+        @block.call(Babylon::Base::View.new(file, hashed_variables).evaluate) if @block
+      end
+    end
+  end
+end

data/lib/babylon/base/view.rb

@@ -0,0 +1,34 @@
+module Babylon
+  module Base
+    
+    ##
+    # Your application's views (stanzas) should be descendant of this class.
+    class View 
+      attr_reader :output, :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
+        assigns.each do |key, value| 
+          instance_variable_set("@#{key}", value)
+          self.class.send(:define_method, key) do # Defining accessors
+            value
+          end
+        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)
+        end
+        return xml.doc.children #we return the doc's children (to avoid the instruct)
+      end
+      
+    end 
+  end 
+end

data/lib/babylon/client_connection.rb

@@ -0,0 +1,188 @@
+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'
+    require 'resolv'
+    
+
+    attr_reader :binding_iq_id, :session_iq_id
+
+    ##
+    # Creates a new ClientConnection and waits for data in the stream
+    def initialize(params)
+      super(params)
+      @state = :wait_for_stream
+    end
+    
+    ##
+    # 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"]
+      
+      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, &block)
+              # 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 #{$!} : #{$!.inspect}"
+        end
+      end
+    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.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(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([jid, jid.split("@").first, @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
+          @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
+      
+      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
+        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)
+          @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
+      end
+
+    end
+
+    ##
+    # Namespace of the client
+    def stream_namespace
+      "jabber:client"
+    end
+
+  end
+end

data/lib/babylon/component_connection.rb

@@ -0,0 +1,71 @@
+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'
+    
+    ##
+    # Creates a new ComponentConnection 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' => "jabber:component:accept", 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.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(@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 + @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"
+          @connection_callback.call(self) if @connection_callback
+          @state = :connected
+        elsif stanza.name == "stream:error"
+          raise AuthenticationError
+        else
+          raise
+        end
+
+      end
+    end
+    
+    ##
+    # Namespace of the component
+    def stream_namespace
+      'jabber:component:accept'
+    end
+    
+  end
+end

data/lib/babylon/router.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__)+"/router/dsl"
+
+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(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
+      sort
+    end
+
+    # Look for the first matching route and calls the corresponding 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
+          Babylon.logger.info("ROUTING TO #{route.controller}::#{route.action}")
+          controller = route.controller.new({:stanza => stanza})
+          controller.perform(route.action) do |response|
+            # Response should be a Nokogiri::Nodeset
+            @@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
+
+    # Run the router DSL.
+    def draw(&block)
+      r = Router::DSL.new
+      r.instance_eval(&block)
+      r.routes.each do |route|
+        raise("Route lacks destination: #{route.inspect}") unless route.is_a?(Route)
+      end
+      @routes ||= []
+      @routes += r.routes
+      sort
+    end
+
+    private
+    def sort
+      @routes.sort! { |r1,r2|
+        r2.priority <=> r1.priority
+      }
+    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_accessor :priority, :controller, :action, :xpath
+    
+    ##
+    # Creates a new route
+    def initialize(params)
+      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"]
+      @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, XpathHelper.new).first ? self : false
+    end
+    
+  end
+  
+end

data/lib/babylon/router/dsl.rb

@@ -0,0 +1,61 @@
+module Babylon
+  module Router
+
+    # Creates a simple DSL for stanza routing.
+    class DSL
+      attr_reader :routes
+
+      def initialize
+        @routes = []
+      end
+
+      # Match an xpath.
+      def xpath(path)
+        @routes << {"xpath" => path}
+        self
+      end
+
+      # Set the priority of the last created route.
+      def priority(n)
+        set(:priority, n)
+        self
+      end
+
+      # Match a disco_info query.
+      def disco_info(node = nil)
+        disco_for(:info, node)
+      end
+
+      # Match a disco_items query.
+      def disco_items(node = nil)
+        disco_for(:items, node)
+      end
+
+      # Map a route to a specific controller and action.
+      def to(params)
+        set(:controller, params[:controller])
+        set(:action, params[:action])
+        # We now have all the properties we really need to create a route.
+        route = Route.new(@routes.pop)
+        @routes << route
+        self
+      end
+
+      protected
+      # We do this magic, or crap depending on your perspective, because we don't know whether we're setting values on a 
+      # Hash or a Route. We can't create the Route until we have a controller and action.
+      def set(property, value)
+        last = @routes.last
+        last[property.to_s] = value if last.is_a?(Hash)
+        last.send("#{property.to_s}=", value) if last.is_a?(Route)
+      end
+
+      def disco_for(type, node = nil)
+        str = "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco##{type.to_s}')"
+        str += " and @node = '#{node}'" if node
+        str += "]"
+        xpath(str)
+      end
+    end
+  end
+end

data/lib/babylon/runner.rb

@@ -0,0 +1,57 @@
+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)
+      
+      Babylon.environment = env
+      
+      # Starting the EventMachine
+      EventMachine.epoll
+      EventMachine.run do
+        
+        # Requiring all models
+        Dir.glob('app/models/*.rb').each { |f| require f }
+
+        # Load the controllers
+        Dir.glob('app/controllers/*_controller.rb').each {|f| require f }
+
+        #  Evaluate routes defined with the new DSL router.
+        CentralRouter.draw do
+          eval File.read("config/routes.rb")
+        end
+        
+        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]
+        
+        params, on_connected = Babylon.config.merge({:on_stanza => Babylon::CentralRouter.method(:route)}), Babylon::CentralRouter.method(:connected)
+        
+        case Babylon.config["application_type"]
+          when "client"
+            Babylon::ClientConnection.connect(params, &on_connected)
+          else # By default, we assume it's a component
+            Babylon::ComponentConnection.connect(params, &on_connected)
+        end
+        
+        # And finally, let's allow the application to do all it wants to do after we started the EventMachine!
+        yield if block_given?
+      end
+    end
+    
+  end
+end

data/lib/babylon/xmpp_connection.rb

@@ -0,0 +1,223 @@
+module Babylon
+
+  ## 
+  # Connection Exception
+  class NotConnected < Exception; end
+
+  ## 
+  # xml-not-well-formed Exception
+  class XmlNotWellFormed < Exception; end
+  
+
+  ##
+  # This class is in charge of handling the network connection to the XMPP server.
+  class XmppConnection < EventMachine::Connection
+    
+    attr_accessor :jid, :host, :port
+    
+    ##
+    # 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)
+      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}))
+    end
+    
+    def connection_completed
+      Babylon.logger.debug("CONNECTED") # Very low level Logging
+    end
+
+    ##
+    # 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
+    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]
+      @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}")
+          # <stream:error><xml-not-well-formed xmlns:xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>
+          raise XmlNotWellFormed
+        end
+        # In any case, we need to close the connection.
+        close_connection
+      else
+        @stanza_callback.call(stanza) if @stanza_callback
+      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.
+    # This method also adds a "from" attribute to all stanza if it was ommited (the full jid) only if a "to" attribute is present. if not, we assume that we're speaking to the server and the server doesn't need a "from" to identify where the message is coming from.
+    def send(xml)
+      if xml.is_a? Nokogiri::XML::NodeSet
+        xml.each do |node|
+          send_node(node)
+        end
+      elsif xml.is_a? Nokogiri::XML::Node
+        send_node(xml)
+      else
+        # We try a cast into a string.
+        send_string("#{xml}")
+      end
+    end
+
+    private
+
+    ##
+    # Sends a node on the "line".
+    def send_node(node)
+      @last_stanza_sent = node
+      node["from"] = jid if !node.attributes["from"] && node.attributes["to"]
+      send_string(node.to_xml)
+    end
+    
+    ## 
+    # Sends a string on the line
+    def send_string(string)
+      Babylon.logger.debug("SENDING : #{string}")
+      send_data("#{string}") 
+    end
+
+    ## 
+    # receive_data is called when data is received. It is then passed to the parser. 
+    def receive_data(data)
+      Babylon.logger.debug("RECEIVED : #{data}")
+      @parser.push(data)
+    end
+  end
+
+  ##
+  # This is the XML SAX Parser that accepts "pushed" content
+  class XmppParser < Nokogiri::XML::SAX::Document
+    
+    attr_accessor :elem, :doc
+    
+    ##
+    # Initialize the parser and adds the callback that will be called upon stanza completion
+    def initialize(&callback)
+      @callback = callback
+      super()
+      reset
+    end
+    
+    ## 
+    # Resets the Pushed SAX Parser.
+    def reset
+      @parser   = Nokogiri::XML::SAX::PushParser.new(self)
+      @doc      = Nokogiri::XML::Document.new
+      @elem     = nil
+    end
+    
+    ##
+    # Pushes the received data to the parser. The parser will then callback the document's methods (start_tag, end_tag... etc)
+    def push(data)
+      @parser << data
+    end
+    
+    ##
+    # Called when the document contains a CData block
+    def cdata_block(string)
+      cdata = Nokogiri::XML::CDATA.new(@doc, string)
+      @elem.add_child(cdata)
+    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)
+      @last_text_elem ||= @elem
+      @last_text = @last_text ? @last_text + string : string
+    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)
+
+      # Adding the newly created element to the @elem that is being parsed, or, if no element is being parsed, then we set the @root and the @elem to be this newly created element.
+      @elem = @elem ? @elem.add_child(e) : (@root = e)
+      
+      if @elem.name == "stream:stream"
+        # Should be called only for stream:stream.
+        # We re-initialize the document and set its root to be the doc.
+        # Also, we activate the callback since this element  will never end.
+        @doc = Nokogiri::XML::Document.new
+        @doc.root = @root = @elem
+        @callback.call(@elem)
+      end
+    end
+
+    ##
+    # Terminates the current element and calls the callback
+    def end_element(name)
+      if @last_text_elem
+        @elem.add_child(Nokogiri::XML::Text.new(@last_text, @doc))
+        @last_text_elem = nil
+        @last_text = nil
+      end
+      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 next sibling or 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/lib/babylon/xpath_helper.rb

@@ -0,0 +1,13 @@
+module Babylon
+
+  # Custom XPath functions for stanza-routing.
+  class XpathHelper
+
+    # Match nodes of the given name with the given namespace URI.
+    def namespace(set, name, nsuri)
+      set.find_all.each do |n|
+        n.name == name && n.namespaces.values.include?(nsuri)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+= 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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,12 @@
+= 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

@@ -0,0 +1,9 @@
+require "rubygems"
+require "babylon"
+require File.dirname(__FILE__)+"/dependencies"
+
+# Start the App
+Babylon::Runner::run(ARGV[0] || "development") do
+  # And the initializers, too. This is done here since some initializers might need EventMachine to be started.
+  Dir[File.join(File.dirname(__FILE__), '/initializers/*.rb')].each {|f| require f }
+end

data/templates/babylon/config/config.yaml

@@ -0,0 +1,26 @@
+# This contains the global configuration of your component.
+# environment:
+#    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
+#    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
+    application_type: client
+
+test:
+    jid: component.server.com
+    password: password
+    host: localhost
+    port: 5278
+        
+production:
+    jid: component.server.com
+    password: password
+    host: localhost
+    port: 5278

data/templates/babylon/config/dependencies.rb

@@ -0,0 +1,2 @@
+# Require any application-specific dependencies here.
+

data/templates/babylon/config/initializers/README.rdoc

@@ -0,0 +1 @@
+Place any application-specific code that needs to be run during initialization in this directory.

data/templates/babylon/config/routes.rb

@@ -0,0 +1,24 @@
+# Routes require an xpath against which to match, and a controller/action pair to which to map.
+#
+# xpath("//message[@type = 'chat']"
+# ).to(:controller => "message", :action => "receive")
+#
+# Routes can be assigned priorities. The highest priority executes first, and the default priority is 0.
+#
+# xpath("//message[@type = 'chat']"
+# ).to(:controller => "message", :action => "priority"
+# ).priority(5000000)
+#
+# It is not possible to easily check for namespace URI equivalence in xpath, but the following helper function was added.
+#
+# xpath("//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco#info')]"
+# ).to(:controller => "discovery", :action => "services")
+#
+# That syntax is ugly out of necessity. But, relax, you're using Ruby.
+#
+# There are a few helper methods for generating xpaths. The following is equivalent to the above example:
+#
+# disco_info.to(:controller => "discovery", :action => "services")
+#
+# See lib/babylon/router/dsl.rb for more helpers.
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: julien51-babylon
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - julien Genestoux
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-18 00:00:00 -07:00
+date: 2009-03-22 00:00:00 -07:00
 default_executable: babylon
 dependencies: []
 
@@ -24,8 +24,27 @@ extra_rdoc_files:
 - LICENSE
 files: 
 - bin/babylon
-- README.rdoc
+- lib/babylon.rb
+- lib/babylon/base/controller.rb
+- lib/babylon/base/view.rb
+- lib/babylon/client_connection.rb
+- lib/babylon/component_connection.rb
+- lib/babylon/router/dsl.rb
+- lib/babylon/router.rb
+- lib/babylon/runner.rb
+- lib/babylon/xmpp_connection.rb
+- lib/babylon/xpath_helper.rb
 - LICENSE
+- Rakefile
+- README.rdoc
+- templates/babylon/app/controllers/README.rdoc
+- templates/babylon/app/models/README.rdoc
+- templates/babylon/app/views/README.rdoc
+- templates/babylon/config/boot.rb
+- templates/babylon/config/config.yaml
+- templates/babylon/config/dependencies.rb
+- templates/babylon/config/routes.rb
+- templates/babylon/config/initializers/README.rdoc
 has_rdoc: true
 homepage: http://github.com/julien51/babylon
 post_install_message: