julien51-babylon 0.1.0 → 0.1.2

data/Rakefile

@@ -9,7 +9,7 @@ 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", "sax-machine", "templater", "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", 

data/lib/babylon.rb

@@ -7,6 +7,11 @@ require 'nokogiri'
 require 'yaml'
 require 'fileutils'
 require 'sax-machine'
+require 'digest/sha1'
+require 'base64'
+require 'resolv'
+require "templater"
+
 
 require 'babylon/xmpp_connection'
 require 'babylon/xmpp_parser'

data/lib/babylon/base/stanza.rb

@@ -1,5 +1,3 @@
-require "sax-machine"
-
 module Babylon
   module Base
     ##

data/lib/babylon/client_connection.rb

@@ -5,9 +5,6 @@ module Babylon
   # 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
 
@@ -56,15 +53,15 @@ module Babylon
     # Builds the stream stanza for this client
     def stream_stanza
       doc = Nokogiri::XML::Document.new
-      stream = Nokogiri::XML::Node.new("stream", doc)
+      stream = Nokogiri::XML::Node.new("stream:stream", doc)
       doc.add_child(stream)
-      stream.add_namespace(nil, stream_namespace())
-      stream.add_namespace("stream", "http://etherx.jabber.org/streams")
+      stream["xmlns"] = stream_namespace
+      stream["xmlns:stream"] = "http://etherx.jabber.org/streams"
       stream["to"] = jid.split("/").first.split("@").last
       stream["version"] = "1.0"
       paste_content_here = Nokogiri::XML::Node.new("paste_content_here", doc)
       stream.add_child(paste_content_here)
-      doc.to_xml.split('<stream:paste_content_here/>').first
+      doc.to_xml.split('<paste_content_here/>').first
     end
 
     ##
@@ -100,7 +97,7 @@ module Babylon
               doc = Nokogiri::XML::Document.new
               starttls = Nokogiri::XML::Node.new("starttls", doc)
               doc.add_child(starttls)
-              starttls.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-tls")
+              starttls["xmlns"] = "urn:ietf:params:xml:ns:xmpp-tls"
               send_xml(starttls.to_s)
               @state = :wait_for_proceed
             elsif stanza.at("mechanisms") # tls is ok
@@ -109,7 +106,7 @@ module Babylon
                 auth = Nokogiri::XML::Node.new("auth", doc)
                 doc.add_child(auth)
                 auth['mechanism'] = "PLAIN"
-                auth.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-sasl")
+                auth["xmlns"] = "urn:ietf:params:xml:ns:xmpp-sasl"
                 auth.content = Base64::encode64([jid, jid.split("@").first, @password].join("\000")).gsub(/\s/, '')
                 send_xml(auth.to_s)
                 @state = :wait_for_success
@@ -142,7 +139,7 @@ module Babylon
               iq["type"] = "set"
               iq["id"] = binding_iq_id.to_s
               bind = Nokogiri::XML::Node.new("bind", doc)
-              bind.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-bind")
+              bind["xmlns"] = "urn:ietf:params:xml:ns:xmpp-bind"
               iq.add_child(bind)
               resource = Nokogiri::XML::Node.new("resource", doc)
               if jid.split("/").size == 2 
@@ -169,7 +166,7 @@ module Babylon
             iq["type"] = "set"
             iq["id"] = session_iq_id.to_s
             session = Nokogiri::XML::Node.new("session", doc)
-            session.add_namespace(nil, "urn:ietf:params:xml:ns:xmpp-session")
+            session["xmlns"] = "urn:ietf:params:xml:ns:xmpp-session"
             iq.add_child(session)
             send_xml(iq.to_s)
             @state = :wait_for_confirmed_session

data/lib/babylon/component_connection.rb

@@ -3,7 +3,6 @@ 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
@@ -19,14 +18,14 @@ module Babylon
     def connection_completed
       super
       doc = Nokogiri::XML::Document.new 
-      stream = Nokogiri::XML::Node.new("stream", doc)
-      stream.add_namespace(nil, stream_namespace)
-      stream.add_namespace("stream", "http://etherx.jabber.org/streams")
+      stream = Nokogiri::XML::Node.new("stream:stream", doc)
+      stream["xmlns"] = stream_namespace
+      stream["xmlns:stream"] = "http://etherx.jabber.org/streams"
       stream["to"] = jid
       doc.add_child(stream)
       paste_content_here= Nokogiri::XML::Node.new("paste_content_here", doc)
       stream.add_child(paste_content_here)
-      start, stop = doc.to_xml.split('<stream:paste_content_here/>')
+      start, stop = doc.to_xml.split('<paste_content_here/>')
       send_xml(start)
     end
 

data/lib/babylon/generator.rb

@@ -1,5 +1,3 @@
-require "templater"
-
 module Babylon
   module Generator
     extend Templater::Manifold

data/lib/babylon/runner.rb

@@ -12,7 +12,9 @@ module Babylon
       Babylon.config = YAML.load(config_file)[Babylon.environment]
       
       # Add an outputter to the logger
-      Babylon.logger.add(Log4r::FileOutputter.new("#{Babylon.environment}", :filename => "log/#{Babylon.environment}.log", :trunc => false))
+      log_file = Log4r::RollingFileOutputter.new("#{Babylon.environment}", :filename => "log/#{Babylon.environment}.log", :trunc => false)
+      log_file.formatter = Log4r::PatternFormatter.new(:pattern => "%d (#{Process.pid}) [%l] :: %m", :date_pattern => "%d/%m %H:%M")
+      Babylon.logger.add(log_file)
       
       # Requiring all models, stanza, controllers
       ['app/models/*.rb', 'app/stanzas/*.rb', 'app/controllers/*_controller.rb'].each do |dir|

data/lib/babylon/xmpp_parser.rb

@@ -89,7 +89,7 @@ module Babylon
     def add_namespaces_and_attributes_to_current_node(attrs) 
       (attrs.size / 2).times do |i|
         name, value = attrs[2 * i], attrs[2 * i + 1]
-        # TODO : FIX namespaces :they give a lot of problems with XPath
+        # TODO : FIX namespaces :they give a lot of problems with Nokogiri
         # if name == "xmlns"
         #   @elem.add_namespace(nil, value)
         # elsif name =~ /\Axmlns:/

data/spec/em_mock.rb

@@ -0,0 +1,42 @@
+## 
+# Mock for EventMachine
+module EventMachine
+
+  def self.mock?
+    true
+  end
+
+  ##
+  # Mock for the Connection Class
+  class Connection
+    def self.new(*args)
+      allocate.instance_eval do
+        # Call a superclass's #initialize if it has one
+        initialize(*args)
+        # Store signature and run #post_init
+        post_init
+        self
+      end
+    end
+  end
+
+  ##
+  # Stub for run
+  def self.run(proc)
+    proc.call
+  end
+
+  ##
+  # Stub for epoll
+  def self.epoll; end
+
+  ##
+  # Stub! to stop the event loop.
+  def self.stop_event_loop; end
+
+  ##
+  # Stub for connect (should return a connection object)
+  def self.connect(host, port, handler, params)
+    handler.new(params)
+  end
+end

data/spec/lib/babylon/base/controller_spec.rb

@@ -0,0 +1,205 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Babylon::Base::Controller do
+  
+  before(:each) do
+    Babylon.views.stub!(:[]).and_return("") # Stubbing read for view
+  end
+  
+  describe ".initialize" do
+    before(:each) do
+      @params = {:a => "a", :b => 1, :c => {:key => "value"}, :stanza => "<hello>world</hello>"}    
+    end
+    
+    it "should have a stanza instance" do
+      stanza = mock(Object)
+      c = Babylon::Base::Controller.new(stanza)
+      
+      c.instance_variables.should be_include "@stanza"
+      c.instance_variable_get("@stanza").should == stanza
+    end
+    
+    it "should not be rendered yet" do
+      c = Babylon::Base::Controller.new(@params)
+      c.rendered.should_not be_true
+    end
+  end
+  
+  describe ".perform" do
+    before(:each) do
+      @action = :subscribe
+      params = {:stanza => "<hello>world</hello>"}
+      @controller = Babylon::Base::Controller.new(params)
+      @controller.class.send(:define_method, @action) do # Defining the action method
+        # Do something
+      end
+    end
+    
+    it "should setup the action to the param" do
+      @controller.perform(@action) do
+        # Do something
+      end
+      @controller.instance_variable_get("@action_name").should == @action
+    end
+    
+    it "should call the action" do
+      @controller.should_receive(:send).with(@action).and_return()
+      @controller.perform(@action) do
+        # Do something
+      end
+    end
+    
+    it "should write an error to the log in case of failure of the action" do
+      @controller.stub!(:send).with(@action).and_raise(StandardError)
+      Babylon.logger.should_receive(:error)
+      @controller.perform(@action) do
+        # Do something
+      end
+    end
+    
+    it "should call render" do
+      @controller.should_receive(:render)
+      @controller.perform(@action) do
+        # Do something
+      end
+    end
+  end
+  
+  describe ".render" do
+    before(:each) do
+      @controller = Babylon::Base::Controller.new({})
+      @controller.action_name = :subscribe
+    end
+    
+    it "should assign a value to view" do
+      @controller.render
+      @controller.instance_variable_get("@view").should_not be_nil
+    end
+    
+    describe "with :nothing option" do
+      it "should not render any file" do
+        @controller.should_not_receive(:render_for_file)
+        @controller.render :nothing => true
+      end
+    end
+    
+    describe "with no option" do
+      it "should call render with default_file_name if no option is provided" do
+        @controller.should_receive(:default_template_name)
+        @controller.render      
+      end
+    end
+    
+    describe "with an :action option" do
+      it "should call render with the file name corresponding to the action given as option" do
+        action = :unsubscribe
+        @controller.should_receive(:default_template_name).with("#{action}")
+        @controller.render(:action => action)
+      end
+    end
+    
+    describe "with a file option" do
+      it "should call render_for_file with the correct path if an option file is provided" do
+        file = "myfile"
+        @controller.should_receive(:render_for_file)
+        @controller.render(:file => file)
+      end
+    end
+    
+    it "should not render twice when called twice" do
+      @controller.render
+      @controller.should_not_receive(:render_for_file)
+      @controller.render      
+    end
+  end
+  
+  describe ".assigns" do
+    
+    before(:each) do
+      @stanza = mock(Babylon::Base::Stanza)
+      @controller = Babylon::Base::Controller.new(@stanza)
+    end
+    
+    it "should be a hash" do
+      @controller.assigns.should be_an_instance_of(Hash)
+    end
+    
+    it "should only contain the @stanza if the action hasn't been called yet" do
+      @controller.assigns.should_not be_empty
+      @controller.assigns["stanza"].should == @stanza
+    end
+    
+    it "should return an hash containing all instance variables defined in the action" do
+      vars = {"a" => 1, "b" => "b", "c" => { "d" => 4}}
+      class MyController < Babylon::Base::Controller
+        def do_something
+          @a = 1
+          @b = "b"
+          @c = { "d" => 4 }
+        end
+      end
+      @controller = MyController.new(@stanza)
+      @controller.do_something
+      @controller.assigns.should == vars.merge("stanza" => @stanza)
+    end
+  end
+  
+  describe ".evaluate" do
+    before(:each) do
+      @controller = Babylon::Base::Controller.new()
+    end
+    
+    it "should evaluate the view" do
+      view = mock(Babylon::Base::View)
+      response = "hello"
+      @controller.instance_variable_set("@view", view)
+      view.should_receive(:evaluate).and_return(response)
+      @controller.evaluate.should == response
+    end
+  end
+  
+  describe ".view_path" do
+    it "should return complete file path to the file given in param" do
+      @controller = Babylon::Base::Controller.new()
+      file_name = "myfile"
+      @controller.__send__(:view_path, file_name).should == File.join("app/views", "#{"Babylon::Base::Controller".gsub("Controller","").downcase}", file_name)
+    end
+  end
+  
+  describe ".default_template_name" do
+    before(:each) do
+      @controller = Babylon::Base::Controller.new()
+    end
+    
+    it "should return the view file name if a file is given in param" do
+      @controller.__send__(:default_template_name, "myaction").should == "myaction.xml.builder"
+    end
+    
+    it "should return the view file name based on the action_name if no file has been given" do
+      @controller.action_name = "a_great_action"
+      @controller.__send__(:default_template_name).should == "a_great_action.xml.builder"
+    end
+  end
+  
+  describe ".render_for_file" do
+    
+    before(:each) do
+      @controller = Babylon::Base::Controller.new()
+      @block = Proc.new {
+        # Do something
+      }
+      @controller.class.send(:define_method, "action") do # Defining the action method
+        # Do something
+      end
+      @controller.perform(:action, &@block) 
+      @view = Babylon::Base::View.new("path_to_a_file", {})
+    end
+    
+    it "should instantiate a new view, with the file provided and the hashed_variables" do
+      Babylon::Base::View.should_receive(:new).with("path_to_a_file",an_instance_of(Hash)).and_return(@view)
+      @controller.__send__(:render_for_file, "path_to_a_file")
+    end
+    
+  end
+
+end

data/spec/lib/babylon/base/stanza_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Babylon::Base::Stanza do
+  
+  describe "initialize" do
+    before(:each) do
+      @stanza_string = "<presence />"
+      @stanza = Babylon::Base::Stanza.new(@stanza_string)
+    end
+    
+    it "should call parse with the string passed to the builder" 
+    
+  end
+  
+end

data/spec/lib/babylon/base/view_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Babylon::Base::View do
+  describe ".initialize" do
+    
+    before(:each) do
+      @view = Babylon::Base::View.new("/a/path/to/a/view/file", {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+    end
+    
+    it "should assign @view_template to path" do
+      @view.view_template == "/a/path/to/a/view/file"
+    end
+    
+    it "should assign any variable passed in hash" do
+      {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}}.each do |key, value|
+        @view.instance_variable_get("@#{key}").should == value
+      end
+    end
+  end
+
+  describe ".evaluate" do
+    before(:each) do
+      @view_template = "/a/path/to/a/view/file"
+      @view = Babylon::Base::View.new(@view_template, {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+      @xml_string = <<-eoxml
+        xml.message(:to => "you", :from => "me", :type => :chat) do
+          xml.body("salut") 
+       end
+      eoxml
+      Babylon.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+    end
+        
+    it "should read the template file" do
+      Babylon.views.should_receive(:[]).twice.with(@view_template).and_return(@xml_string)
+      @view.evaluate
+    end
+    
+    it "should raise an error if the view file couldn't be found" do
+      Babylon.views.stub!(:[]).with(@view_template).and_raise(nil)
+      lambda {
+        @view.evaluate
+      }.should raise_error(Babylon::Base::ViewFileNotFound)
+    end
+    
+    it "should return a Nokogiri NodeSet" do
+      Babylon.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+      @view.evaluate.should be_an_instance_of(Nokogiri::XML::NodeSet)
+    end
+    
+    it "should call eval on the view file" do
+      Babylon.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+      @view.should_receive(:eval).with(@xml_string)
+      @view.evaluate
+    end
+    
+    it "should be able to access context's variables" do
+      @view = Babylon::Base::View.new("/a/path/to/a/view/file", {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+      @view.instance_variable_get("@a").should == "a"
+      @view.instance_variable_get("@b").should == 123
+      @view.instance_variable_get("@c").should == {:e=>"123", :d=>"d"}
+    end
+  end
+  
+end