julien51-babylon 0.0.3

data/README.rdoc

@@ -0,0 +1,89 @@
+= babylon
+
+== DESCRIPTION:
+
+Babylon is a framework to EventMachine based XMPP External Components in Ruby.
+
+== 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 :
+
+- Instead of passing the stanzas as Nokogiri:XML:Node elements we should find a way to pass an "agnostic" datastructure, so that app developers don't have to learn/know/understand Nokogiri
+- Adding the ability to send several messages all at once (like render :collection in Rails)
+
+== SYNOPSIS:
+
+1. Install the gem
+2. The app contains a generator that will "build" a scaffold for your application. 
+    
+    $> babylon myapp
+
+3. Write your own "controllers"
+
+/app/controllers/message_controller.rb 
+
+    class MessageController < Babylon::Base::Controller  
+      # Each controller is initiated with the stanza.(similar to params in rails actions)
+
+      def echo
+        # We do stuff here
+        @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 :
+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)
+    end
+
+5. 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!
+
+== REQUIREMENTS:
+
+Our goal is to limit the number of dependencies. Nokogiri seems to be only XML Library on Ruby that has a Push SAX Parser, that is why we are using it. It also seems pretty 'fast'.
+Gems : Eventmachine, nokogiri
+
+== INSTALL:
+
+- sudo gem install babylon
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Julien Genestoux http://notifixio.us
+
+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/bin/babylon

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+# Generates the stubs for a new Babylon Application
+# This will generate the right hierarchy for a Babylon App
+# First, let's create the app directoryn based in ARGV[0]
+
+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 "
+end

data/lib/babylon.rb

@@ -0,0 +1,24 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'eventmachine'
+require 'nokogiri'
+
+require 'babylon/xmpp_connection'
+require 'babylon/component_connection'
+require 'babylon/router'
+require 'babylon/runner'
+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
+  # 0.0.3 : Not suited for production, use at your own risks
+  VERSION = '0.0.3'
+end
+

data/lib/babylon/base/controller.rb

@@ -0,0 +1,62 @@
+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 = {})
+        @stanza = params[:stanza]
+        @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(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)
+        "app/views/#{self.class.name.gsub("Controller","").downcase}/#{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)
+        view = Babylon::Base::View.new(file, hashed_variables)
+        @block.call(view.evaluate)
+      end
+    end
+  end
+end

data/lib/babylon/base/view.rb

@@ -0,0 +1,50 @@
+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.to_xml #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/component_connection.rb

@@ -0,0 +1,61 @@
+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(*a)
+      super
+      @state = :wait_for_stream
+    end
+
+    ##
+    # XMPP Component handshake as defined in XEP-0114:
+    # http://xmpp.org/extensions/xep-0114.html
+    def receive_stanza(stanza)
+      case @state
+
+      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
+          # callback the controllers to tell them we're connected!
+          # TODO
+          @state = :connected
+        else
+          raise
+        end
+
+      when :connected
+        super # Can be dispatched
+      end
+    end
+    
+    ##
+    # Namespace of the component
+    def stream_namespace
+      'jabber:component:accept'
+    end
+    
+    ##
+    # Jid of the component
+    def stream_to
+      @config['jid']
+    end
+  end
+end

data/lib/babylon/router.rb

@@ -0,0 +1,79 @@
+module Babylon
+  
+  ##
+  # The router is in charge of sending the right stanzas to the right controllers based on user defined Routes.
+  module Router
+    
+    ##
+    # 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
+    
+    ##
+    # 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(connection, stanza)
+      @routes ||= []
+      @routes.each { |route|
+        if route.accepts?(connection, stanza)
+          # Here should happen the magic : call the controller
+          controller = route.controller.new({:stanza => stanza})
+          controller.perform(route.action) do |response|
+            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?(connection, stanza)
+      stanza.xpath(@xpath, stanza.namespaces).first ? self : false
+    end
+    
+  end
+  
+end

data/lib/babylon/runner.rb

@@ -0,0 +1,31 @@
+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
+    def self.run(env = "development")
+      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
+        Babylon::ComponentConnection.connect(config)
+      end
+    end
+    
+  end
+end

data/lib/babylon/xmpp_connection.rb

@@ -0,0 +1,161 @@
+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)
+      EventMachine::connect config['host'], config['port'], self, config
+    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)
+      puts "<< #{stanza}\n"  if debug? # Low level Logging 
+      # If not handled by subclass (for authentication)
+      CentralRouter.route self, stanza
+    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 {
+        self.send('stream:stream', 'xmlns' => "jabber:component:accept", 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.config['jid']) {
+          paste_content_here #  The stream:stream element should be cut here ;)
+        }
+      }
+      @start_stream, @stop_stream = builder.to_xml.split('<paste_content_here/>')
+      send_data(@start_stream)
+    end
+    
+    ## 
+    # Sends data (string) on the stream. Eventually it displays this data for debugging purposes
+    def send(xml)
+      puts ">> #{xml}\n" if debug? # Very low level Logging
+      send_data xml.to_s
+    end
+
+    private
+
+    ## 
+    # receive_data is called when data is received. It is then passed to the parser. 
+    def receive_data(data)
+      @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.parent.nil?
+        # Should be called only for stream:stream
+        @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

@@ -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,8 @@
+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

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

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

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

data/templates/babylon/scripts/generate

@@ -0,0 +1,47 @@
+#!/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"
+

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: julien51-babylon
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Julien Genestoux
+- Astro
+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
+executables: 
+- babylon
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- lib/babylon.rb
+- lib/babylon/base/controller.rb
+- lib/babylon/base/view.rb
+- lib/babylon/component_connection.rb
+- lib/babylon/router.rb
+- lib/babylon/runner.rb
+- lib/babylon/xmpp_connection.rb
+- 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
+has_rdoc: true
+homepage: http://github.com/julien51/babylon/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Babylon is a framework to create EventMachine based XMPP External Components in Ruby.
+test_files: []
+