julien51-babylon 0.0.11 → 0.0.12

data/README.rdoc

@@ -1,86 +1,73 @@
-= babylon
+= Babylon
 
 == DESCRIPTION:
 
 Babylon is a framework to build XMPP Applications in Ruby. The framework uses EventMachine to handle network connections.
 
-This framework can use both an XMPP Component (XEP-0114) and an XMPP Client. However, we strongly discourage any production application using a regular client.
+This framework can use both an XMPP Component (XEP-0114) and an XMPP Client (and XMPP Servers should come soone). However, we strongly discourage any production application using a regular client.
 
 == FEATURES/PROBLEMS:
 
+Please report/request them at the Lighthouse : http://babylon.lighthouseapp.com/projects/27641-babylon/overview
+
+The current version is a good candidate for version 0.1. We will probably not add any important features before that release, but we need some help with the tests and documentation.
+
 == ROADMAP :
 
-- Instead of passing the stanzas as Nokogiri:XML:Node elements we should find a way to pass an "agnostic" ruby data-structure, so that app developers don't have to learn/know/understand Nokogiri
 - Improve the Client Connection to support other authentication than PLAIN SASL
+- Implement the ServerConnection for S2S
+- Implement "auto-responding" features for disco-info... etc
+- Use a better generator (the next version of Nokogiri should fix that)
+- Implement "background" running when in production (and adjust log level)
+- Delete route priorities? And rely on the order only? (As Rails does)
+- Review doc
+- Write more spec
+- Write tests
+- Evangelize!
+
+You can help with at least one of these points, don't turn your back on Babylon!
+
+== DOCUMENTATION :
+
+You can find it on our Rubyforge page : http://babylon.rubyforge.org/
+Please note that the documentation is probably incomplete... so if you have any problems with something that is not clear enough to you, feel free to send us questions and do not hesitate to fork the project to add your own documentation. We will be more than happy to help you help us!
 
-== SYNOPSIS:
+== SYNOPSIS :
 
 You can build applications directly with Babylon, or you can use the Babylon::ClientConnection and Babylon::ComponentConnection to create simple apps, but you will then have to handle stanza routing and creation yourself. You can also use these classes in external gems.
 
-To create an Application with Babylon: 
+=== To create an Application with Babylon: 
 
 1. Install the gem
 2. The app contains a generator that will "build" a scaffold for your application. 
     
-    $> babylon myapp
+    $> babylon application <myapp>
 
 3. Use the generator or write your own controllers : 
 
-    $> 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.rb 
-
-4. Write your application's code and views :
-
-/app/controllers/message_controller.rb 
-
-    class MessageController < Babylon::Base::Controller
-
-      def echo
-        extract_to_and_from
-        body = @stanza.xpath("//message/body").first
-        @resp = body.text.reverse
-      end
+    $> babylon controller messages echo:10://message[@type='chat']/body,subscribed:0://presence[@type='subscribe']
 
-      def subscribed
-        extract_to_and_from
-        @ack = "Thanks for following me!"
-      end
+This will generate a "MessagesController" class with 2 methods : echo and subscribed. 
+ - "echo" will be called when the component receives message stanzas of type 'chat', 
+ - "subscribed" will be called for presence stanzas of type 'subscribe'. 
+10 and 0 are the priority : useful when a stanza matches 2 XPath.  
 
-      protected
+Each of these actions will be called with stanza objects. You have to define your own objects in stanzas/echo.rb and stanzas/subscribed.rb
+By defining them, you can choose which elements and attributes you want to have access to. These attributes will be populated upon instantiation of the Stanza objects.
 
-      def extract_to_and_from
-        @from = @stanza.attributes["to"].text
-        @to = @stanza.attributes["from"].text
-      end
+This will also generate 2 'views' used to build your responses stanzas. 
 
-    end
-    
-
-5. Implement the corresponding views (used to generate the messages). Babylon uses the same file conventions as Rails : a subdirectory for each controller, and one file per action :
-Compared to Rails, we are using accessors (and not @variables assigned in the controller). 
-
-/app/views/message/echo.xml.builder 
-
-    self.message(:to => to, :from => from, :type => :chat) do
-        self.body(resp)
-    end
-
-/app/views/message/subscribed.xml.builder
+And finally, this will write 2 routes in the config/routes.rb 
 
-    self.message(:to => to, :from => from, :type => :chat) do
-      self.body(ack) # Same as self.send(:body, body) 
-    end
+4. Customize your controllers, stanzas and views!
 
-6. Make sure that the XMPP settings are correct in config/config.yaml. !!! You need to have a Jabber Component, regular clients will NOT work!!!
+5. Make sure that the XMPP settings are correct in config/config.yaml. !!! You need to have a Jabber Component, regular clients will NOT work!!!
 
-
-7. And finally start the component :
+6. And finally start the component :
     
     script/component
 
-
-If you just want to make use of the connection classes (Client or Component), you can just call the following :
+=== To use the Connection Classes only (Client or Component), you can just call the following :
 
 Babylon::ClientConnection.connect(params, handler) 
 or,
@@ -88,22 +75,17 @@ Babylon::ComponentConnection.connect(params, handler)
 
 where params is a hash for all the necessary information to connect, and handler is an object that will receive the callbacks. Right now 3 callbacks are supported:
 
-on_connected, on_disconnected and on_stanza
-
-
-== ADDITIONAL INFORMATION
-
-This code hasn't been 100% tested. Feel free to pull, branch, improve {code|specs|tests|docs} and we will merge it!
+on_connected(connection), on_disconnected and on_stanza(stanza)
 
-== REQUIREMENTS:
+== ADDITIONAL INFORMATION : 
 
-Gems : Eventmachine, nokogiri, YAML
+Feel free to pull, branch, improve and commit the {code|specs|tests|docs} : we will merge it if it's a step ahead!
 
-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'. However, we think it is bad to "force" the framework users to receive Nokogiri objects (too much coupling), so we're looking for a Ruby datastcuture that would have an easy mapping with XML. Any thoughts?
+Babylon's edge versions are located at Github : http://github.com/julien51/babylon/tree/master
 
-== INSTALL:
+== REQUIREMENTS :
 
-- sudo gem install babylon
+Gems : Eventmachine, nokogiri, YAML, log4r, sax-machine
 
 == LICENSE:
 

data/Rakefile

@@ -9,11 +9,35 @@ begin
     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.requirements = ["eventmachine", "yaml", "fileutils", "log4r", "nokogiri", "sax-machine"]
     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/xmpp_parser.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.rubyforge_project = 'babylon' # This line would be new
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    gem.files = [ "bin/babylon", 
+                  "lib/babylon.rb", 
+                  "lib/babylon/base/controller.rb", 
+                  "lib/babylon/base/view.rb", 
+                  "lib/babylon/base/stanza.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/generator.rb", 
+                  "lib/babylon/xmpp_connection.rb", 
+                  "lib/babylon/xmpp_parser.rb", 
+                  "lib/babylon/xpath_helper.rb", 
+                  "LICENSE", 
+                  "Rakefile", 
+                  "README.rdoc", 
+                  "templates/babylon/app/controllers/controller.rb", 
+                  "templates/babylon/app/views/view.rb", 
+                  "templates/babylon/app/stanzas/stanza.rb", 
+                  "templates/babylon/config/boot.rb", 
+                  "templates/babylon/config/config.yaml", 
+                  "templates/babylon/config/dependencies.rb", 
+                  "templates/babylon/config/routes.rb", 
+                  "templates/babylon/script/component"
+                  ]
+    gem.rubyforge_project = 'babylon'
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
@@ -22,10 +46,10 @@ end
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = 'babylon'
-  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.title = 'Babylon : a framework to create EventMachine based XMPP External Components in Ruby.'
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--line-numbers'
 end
 
 require 'rake/testtask'

data/bin/babylon

@@ -1,14 +1,6 @@
 #!/usr/bin/env ruby
+ 
+require 'rubygems'
+require 'babylon'
 
-# 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]
-
-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 "Usage: #{$0} <app_name>"
-end
+Babylon::Generator.run_cli(Dir.pwd, 'babylon_app', "0.1", ARGV)

data/lib/babylon.rb

@@ -6,6 +6,7 @@ require 'log4r'
 require 'nokogiri'
 require 'yaml'
 require 'fileutils'
+require 'sax-machine'
 
 require 'babylon/xmpp_connection'
 require 'babylon/xmpp_parser'
@@ -13,15 +14,17 @@ require 'babylon/component_connection'
 require 'babylon/client_connection'
 require 'babylon/router'
 require 'babylon/runner'
+require 'babylon/generator'
 require "babylon/xpath_helper"
 require 'babylon/base/controller'
 require 'babylon/base/view'
+require 'babylon/base/stanza'
 
 # 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
+# This will generate some folders and files for your application. Please see README.rdoc for further instructions
 
 module Babylon
 

data/lib/babylon/base/controller.rb

@@ -73,8 +73,8 @@ module Babylon
       
       # 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
+        Babylon.logger.info("RENDERED : #{file}")
       end
     end
   end

data/lib/babylon/base/stanza.rb

@@ -0,0 +1,27 @@
+require "sax-machine"
+
+module Babylon
+  module Base
+    ##
+    # Class used to Parse a Stanza on the XMPP stream.
+    # You should have a Stanza subsclass for each of your controller actions, as they allow you to define which stanzas and which information is passed to yoru controllers.
+    #
+    # You can define your own macthing pretty easily with the element and elements methods, as explained in the SaxMachine Documentation: http://github.com/pauldix/sax-machine/tree/master
+    # if your stanza is a message stanza, you can match the following for example:
+    # element :message, :value => :to, :as => :to 
+    # element :message, :value => :from, :as => :from 
+    # element :message, :value => :id, :as => :stanza_id 
+    # element :message, :value => :type, :as => :stanza_type 
+    # element :message, :value => :"xml:lang", :as => :lang 
+    
+    class Stanza
+      
+      include SAXMachine
+      
+      def initialize(xml = nil)
+        @xml = xml
+        parse("#{xml}")
+      end
+    end
+  end
+end

data/lib/babylon/generator.rb

@@ -0,0 +1,132 @@
+require "templater"
+
+module Babylon
+  module Generator
+    extend Templater::Manifold
+    
+    desc <<-DESC
+      Babylon is a framework to generate XMPP Applications in Ruby."
+    DESC
+    
+    ##
+    # Generates a Babylon Application
+    class ApplicationGenerator < Templater::Generator
+      desc <<-DESC
+        Generates the file architecture for a Babylon Application. To run, you MUST provide an application name"
+      DESC
+      
+      first_argument :application_name, :required => true, :desc => "Your application name."
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), '../../templates/babylon')
+      end
+      
+      # Create all subsdirectories
+      empty_directory :app_directory do |d|
+        d.destination = "#{application_name}/app"
+      end
+      empty_directory :controllers_directory do |d|
+        d.destination = "#{application_name}/app/controllers"
+      end
+      empty_directory :views_directory do |d|
+        d.destination = "#{application_name}/app/views"
+      end
+      empty_directory :views_directory do |d|
+        d.destination = "#{application_name}/app/stanzas"
+      end
+      empty_directory :models_directory do |d|
+        d.destination = "#{application_name}/app/models"
+      end
+      empty_directory :initializers_directory do |d|
+        d.destination = "#{application_name}/config/initializers"
+      end
+      
+      # And now add the critical files
+      file :boot_file do |f|
+        f.source = "#{source_root}/config/boot.rb"
+        f.destination = "#{application_name}/config/boot.rb"
+      end
+      file :config_file do |f|
+        f.source = "#{source_root}/config/config.yaml"
+        f.destination = "#{application_name}/config/config.yaml"
+      end
+      file :dependencies_file do |f|
+        f.source = "#{source_root}/config/dependencies.rb"
+        f.destination = "#{application_name}/config/dependencies.rb"
+      end
+      file :dependencies_file do |f|
+        f.source = "#{source_root}/config/routes.rb"
+        f.destination = "#{application_name}/config/routes.rb"
+      end
+      file :component_file do |f|
+        f.source = "#{source_root}/script/component"
+        f.destination = "#{application_name}/script/component"
+      end
+      
+    end
+    
+    ##
+    # Generates a new controller, with the corresponding stanzas and routes.
+    class ControllerGenerator < Templater::Generator
+      desc <<-DESC
+        Generates a new controller for the current Application. It also adds the corresponding routes and actions, based on a Xpath and priority. \nSyntax: babylon controller <controller_name> [<action_name>:<priority>:<xpath>],[...]"
+      DESC
+      
+      first_argument  :controller_name, :required => true,   :desc => "Name of the Controller."
+      second_argument :actions_arg,      :required => true,  :as => :array,      :default => [], :desc => "Actions implemented by this controller. Use the following syntax : name:priority:xpath"
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), '../../templates/babylon/app/controllers')
+      end
+      
+      def controller_actions
+        @controller_actions ||= actions_arg.map { |a| a.split(":") }
+      end
+      
+      def controller_class_name
+        "#{controller_name.capitalize}Controller"
+      end
+      
+      ##
+      # This is a hack since Templater doesn't offer any simple way to edit files right now...
+      def add_route_for_actions_in_controller(actions, controller)
+        sentinel = "Babylon::CentralRouter.draw do"
+        router_path = "config/routes.rb"
+        actions.each do |action|
+          to_inject = "xpath(\"#{action[2]}\").to(:controller => \"#{controller}\", :action => \"#{action[0]}\").priority(#{action[1]})"
+          if File.exist?(router_path)
+            content = File.read(router_path).gsub(/(#{Regexp.escape(sentinel)})/mi){|match| "#{match}\n\t#{to_inject}"}
+            File.open(router_path, 'wb') { |file| file.write(content) }
+          end
+        end
+      end
+      
+      template :controller do |t|
+        t.source = "#{source_root}/controller.rb"
+        t.destination = "app/controllers/#{controller_name}_controller.rb"
+        self.add_route_for_actions_in_controller(controller_actions, controller_name)
+        # This is a hack since Templater doesn't offer any simple way to write several files from one...
+        FileUtils.mkdir("app/views/#{controller_name}") unless File.exists?("app/views/#{controller_name}")
+        controller_actions.each do |action|
+          FileUtils.cp("#{source_root}/../views/view.rb", "app/views/#{controller_name}/#{action[0]}.xml.builder")
+        end
+        
+        # And now, let's create the stanza files
+        controller_actions.each do |action|
+          FileUtils.cp("#{source_root}/../stanzas/stanza.rb", "app/stanzas/#{action[0]}.rb")
+          # We need to replace 
+          # "class Stanza < Babylon::Base::Stanza" with "class #{action[0]} < Babylon::Base::Stanza"
+          content = File.read("app/stanzas/#{action[0]}.rb").gsub("class Stanza < Babylon::Base::Stanza", "class #{action[0].capitalize} < Babylon::Base::Stanza")
+          File.open("app/stanzas/#{action[0]}.rb", 'wb') { |file| file.write(content) }
+        end
+      end
+    end
+    
+    # The generators are added to the manifold, and assigned the names 'wiki' and 'blog'.
+    # So you can call them <script name> blog merb-blog-in-10-minutes and
+    # <script name> blog merb-wiki-in-10-minutes, respectively
+    add :application, ApplicationGenerator
+    add :controller, ControllerGenerator
+    
+  end
+end

data/lib/babylon/router.rb

@@ -2,6 +2,11 @@ require File.dirname(__FILE__)+"/router/dsl"
 
 module Babylon
   
+  
+  ## 
+  # Undefined stanza
+  class UndefinedStanza < Exception; end
+  
   ##
   # The router is in charge of sending the right stanzas to the right controllers based on user defined Routes.
   module Router
@@ -46,7 +51,12 @@ module Babylon
         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})
+          # Parsing the stanza
+          begin
+            controller = route.controller.new({:stanza => Kernel.const_get(route.action.capitalize).new(stanza)})
+          rescue NameError
+            raise UndefinedStanza
+          end
           controller.perform(route.action) do |response|
             # Response should be a Nokogiri::Nodeset
             @@connection.send(response)
@@ -84,7 +94,7 @@ module Babylon
   end
 
   ##
-  # Main router where all dispatchers shall register.
+  # Main router for a Babylon Application.
   module CentralRouter
     extend Router
   end

data/lib/babylon/runner.rb

@@ -20,6 +20,9 @@ module Babylon
         # Requiring all models
         Dir.glob('app/models/*.rb').each { |f| require f }
 
+        # Requiring all stanzas
+        Dir.glob('app/stanzas/*.rb').each { |f| require f }
+
         # Load the controllers
         Dir.glob('app/controllers/*_controller.rb').each {|f| require f }
 

data/templates/babylon/app/controllers/controller.rb

@@ -0,0 +1,7 @@
+class <%= controller_class_name %> < Babylon::Base::Controller  
+  <% controller_actions.each do |action, prio, xpath| %>
+    def <%= action %>
+      # This will be called when a stanza matches <%= xpath %>
+    end
+  <% end %>
+end

data/templates/babylon/app/stanzas/stanza.rb

@@ -0,0 +1,6 @@
+class Stanza < Babylon::Base::Stanza 
+  # element :message, :as => :to, :value => :to (will add a .to method for your <message> stanza, based on the "to" attribute)
+  # element :pubsub (will match to the content of <pubsub> and define a .pubsub method)
+  # element :publish, :as => :node, :value => :node (will match to the content of the "node" attribute of <publish> and defined a .node method)
+  # elements :entry, :as => :entries, :class => AtomEntry (will match <entry> elements to a subclass AtomEntry (that you must define, using SaxMachine) and create a .entries.methods that returns an Array of AtomEntry.
+end

data/templates/babylon/app/views/view.rb

@@ -0,0 +1,6 @@
+# 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 : http://nokogiri.rubyforge.org/nokogiri/Nokogiri/XML/Builder.html ).
+
+# xml.message(:to => @to, :from => @from, :type => :chat) do
+#     xml.body(@body) # Same as self.send(:body, body)
+# end

data/templates/babylon/config/boot.rb

@@ -1,6 +1,6 @@
 require "rubygems"
 require "babylon"
-require File.dirname(__FILE__)+"/dependencies"
+require File.dirname(__FILE__) + "/dependencies"
 
 # Start the App
 Babylon::Runner::run(ARGV[0] || "development") do

data/templates/babylon/config/routes.rb

@@ -1,18 +1,14 @@
 # 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")
+# 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)
+# 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")
+# 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.
 #
@@ -21,4 +17,6 @@
 # disco_info.to(:controller => "discovery", :action => "services")
 #
 # See lib/babylon/router/dsl.rb for more helpers.
-
+Babylon::CentralRouter.draw do
+  
+end

data/templates/babylon/script/component

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: julien51-babylon
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors: 
 - julien Genestoux
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-26 00:00:00 -07:00
+date: 2009-03-31 00:00:00 -07:00
 default_executable: babylon
 dependencies: []
 
@@ -27,25 +27,27 @@ files:
 - lib/babylon.rb
 - lib/babylon/base/controller.rb
 - lib/babylon/base/view.rb
+- lib/babylon/base/stanza.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/generator.rb
 - lib/babylon/xmpp_connection.rb
 - lib/babylon/xmpp_parser.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/app/controllers/controller.rb
+- templates/babylon/app/views/view.rb
+- templates/babylon/app/stanzas/stanza.rb
 - 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
+- templates/babylon/script/component
 has_rdoc: true
 homepage: http://github.com/julien51/babylon
 post_install_message: 
@@ -72,6 +74,7 @@ requirements:
 - fileutils
 - log4r
 - nokogiri
+- sax-machine
 rubyforge_project: babylon
 rubygems_version: 1.2.0
 signing_key: 

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/initializers/README.rdoc

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