mohiam-babylon 0.1.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

@@ -0,0 +1,111 @@
+= 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 (and XMPP Servers should come soon). However, we strongly discourage any production application using a regular client.
+
+== FEATURES/PROBLEMS:
+
+Please link "report/request here.":http://github.com/julien51/babylon/issues
+
+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 :
+
+- Implement the ServerConnection for S2S
+- Implement templates for disco-info... and common XEPs
+- Delete route priorities? And rely on the order only? (As Rails does)
+- Review doc
+- 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/
+Feel free to fork the "github":http://github.com/julien51/babylon/tree/master repo and add some documentation if you think anything is missing. 
+
+__You can't be a bad coder, a bad tester and a bad documenter at the same time ;)__
+
+== 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: 
+
+1. Install the gem
+2. The app contains a generator that will "build" a scaffold for your application. 
+    
+    $> babylon application __myapp__
+
+3. Use the generator or write your own controllers : 
+
+    $> babylon controller __messages__ __echo__:__10__:__//stream:message[@type='chat']/body__,__subscribed__:__0__:__//stream:presence[@type='subscribe']__
+
+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.  
+
+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 implementing 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.
+
+This will also generate 2 'views' used to build your responses stanzas. 
+
+And finally, this will write 2 routes in the config/routes.rb 
+
+4. Customize your controllers, stanzas and views!
+
+5. Make sure that the XMPP settings are correct in config/config.yaml. 
+
+6. And finally start the component :
+    
+    script/component
+
+=== To use the Connection Classes only (Client or Component), you can just call the following :
+
+Babylon::ClientConnection.connect(params, handler) 
+or,
+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(connection), on_disconnected and on_stanza(stanza)
+
+== ADDITIONAL INFORMATION : 
+
+Feel free to pull, branch, improve and commit the {code|specs|tests|docs} : we will merge it if it's a step ahead!
+
+Babylon's edge versions are located at Github : http://github.com/julien51/babylon/tree/master
+
+== REQUIREMENTS :
+
+Gems : Eventmachine, nokogiri (please, use build from the guthub repo, since 1.2.3 is not supported by Babylon), YAML, log4r, sax-machine, templater, daemons
+
+== 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/Rakefile

@@ -0,0 +1,145 @@
+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.add_dependency('eventmachine')
+    gem.add_dependency('log4r')
+    gem.add_dependency('nokogiri', ">= 1.3.0")
+    gem.add_dependency('eventmachine')
+    gem.add_dependency('julien51-sax-machine')
+    gem.add_dependency('templater')
+    gem.add_dependency('daemons')
+    gem.requirements = ["eventmachine", "yaml", "fileutils", "log4r", "nokogiri", "sax-machine", "templater", "daemons", "optparse", "digest/sha1", "base64", "resolv"]
+    gem.executables = "babylon"
+    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",
+                  "templates/babylon/log/test.log",
+                  "templates/babylon/log/development.log",
+                  "templates/babylon/log/production.log",
+                  "templates/babylon/tmp/pids/README"
+                  ]
+    gem.rubyforge_project = 'babylon'
+  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 : 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'
+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
+
+begin
+  require 'spec/rake/spectask'
+  desc "Run all Spec"
+  Spec::Rake::SpecTask.new('spec') do |spec|
+    spec.spec_files = FileList['spec/**/*.rb']
+    spec.verbose = true
+    spec.warning = false
+    spec.rcov = true
+  end
+rescue LoadError
+  task :spec do
+    abort "Rspec is not available. In order to run rspec, you must: sudo gem install rspec"
+  end
+end
+
+begin
+  require 'spec/rake/verify_rcov'
+
+  RCov::VerifyTask.new(:verify_rcov => 'spec') do |t|
+    t.threshold = 100.0
+    t.index_html = 'coverage/index.html'
+  end
+rescue LoadError
+  task :spec do
+    abort "Rcov is not available. In order to run rcov, you must: sudo gem install rcov"
+  end
+end
+
+# These are Rubyforge tasks
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/babylon"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end
+
+
+task :install => :build
+
+task :default => :test

data/bin/babylon

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+ 
+require 'rubygems'
+require 'babylon'
+
+Babylon::Generator.run_cli(Dir.pwd, 'babylon_app', "0.1", ARGV)

data/lib/babylon.rb

@@ -0,0 +1,119 @@
+$:.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 'sax-machine'
+require 'digest/sha1'
+require 'base64'
+require 'resolv'
+require "templater"
+require 'extlib'
+
+
+require 'babylon/xmpp_connection'
+require 'babylon/xmpp_parser'
+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.rdoc 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
+  
+  ##
+  # Sets up the router
+  def self.router=(router)
+    @@router = router
+  end
+  
+  ##
+  # Retruns the router
+  def self.router
+    unless self.class_variable_defined?("@@router")
+      @@router = nil
+    end
+    @@router
+  end
+  
+  ##
+  # Caches the view files to improve performance.  
+  def self.cache_views
+    @@views= {}
+    Dir.glob('app/views/**/*').each do |f|
+      Babylon.logger.debug("adding view #{f}")
+      @@views[f] = File.read(f) if File.file?(f)
+    end        
+  end
+  
+  def self.views
+    unless self.class_variable_defined?("@@views")
+      @@views= {}
+    end
+    @@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.stdout) if Babylon.environment == "development"
+    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
+  
+  ##
+  # Decodes XML special characters.
+  def self.decode_xml(str)
+    entities = {
+      'lt'    => '<',
+      'gt'    => '>',
+      '#38'   => '&',
+      'amp'   => '&',
+      'quot'  => '"',
+      '#13'   => "\r",
+    } 
+    entities.keys.inject(str) { |string, key|
+      string.gsub(/&#{key};/, entities[key])
+    } 
+  end
+  
+end
+

data/lib/babylon/base/controller.rb

@@ -0,0 +1,116 @@
+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(stanza = nil)
+        @stanza = stanza
+        @view = nil
+        
+        # used to render basic strings
+        @content = nil
+      end
+      
+      ##
+      # Performs the action and calls back the optional block argument : you should not override this function
+      def perform(action)
+        @action_name = action
+        begin
+          self.send(@action_name)
+        rescue
+          Babylon.logger.error {
+            "#{$!}:\n#{$!.backtrace.join("\n")}"
+          }
+        end
+        self.render
+      end
+      
+      ##
+      # Returns the list of variables assigned during the action.
+      def assigns
+        vars = Hash.new
+        instance_variables.each do |var|
+          if !["@view", "@action_name", "@block"].include? var
+            vars[var[1..-1]] = instance_variable_get(var)
+          end
+        end
+        vars
+      end
+      
+      ##
+      # Called by default after each action to "build" a XMPP stanza. By default, it will use the /controller_name/action.xml.builder
+      # You can use the following options :
+      #   - :file : render a specific file (can be in a different controller)
+      #   - :action : render another action of the current controller
+      #   - :nothing : doesn't render anything
+      def render(options = {}) 
+        return if @view and !options[:force] # Avoid double rendering, if we have already attached a view
+        
+        if options == :nothing
+          @view = Babylon::Base::View.new()
+        elsif options.kind_of? String
+          @content = options
+        elsif options == {} # default rendering
+          # Babylon.logger.debug("rendering default view #{default_template_name}")
+          result = render(:file => default_template_name)
+        elsif options[:file]
+          file = options[:file]
+          if file =~ /^\// # Render from view root
+            result = render_for_file(File.join("app", "views", "#{file}.xml.builder"))
+          else
+            Babylon.logger.debug("rendering from here #{file} #{view_path(file)}")
+            result = render_for_file(view_path(file)) 
+          end
+        elsif action_name = options[:action]
+          result = render(:file => default_template_name(action_name.to_s))
+        elsif options[:nothing]
+          @view = Babylon::Base::View.new()
+        end
+      end
+      
+      ##
+      # Actually evaluates the view
+      def evaluate
+        return @view.evaluate if @view
+        return @content
+      end
+      
+      protected
+      
+      ##
+      # Builds the view path.
+      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)
+        "#{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)
+        
+        # if the view doesn't exist, then don't render it
+        return unless File.exists?(file)
+        
+        Babylon.logger.info {
+          "RENDERING : #{file}"
+        }
+        @view = Babylon::Base::View.new(file, assigns)
+        Babylon.logger.info {
+          " "
+        }
+      end
+      
+    end
+  end
+end