skates 0.1.11

data/lib/skates/xmpp_parser.rb

@@ -0,0 +1,117 @@
+module Skates
+
+  ##
+  # This is the XML SAX Parser that accepts "pushed" content
+  class XmppParser < Nokogiri::XML::SAX::Document
+    
+    attr_accessor :elem, :doc, :parser
+    
+    ##
+    # Initialize the parser and adds the callback that will be called upon stanza completion
+    def initialize(callback)
+      @callback = callback
+      @buffer = ""
+      super()
+      reset
+    end
+    
+    ## 
+    # Resets the Pushed SAX Parser.
+    def reset
+      @parser = Nokogiri::XML::SAX::PushParser.new(self, "UTF-8")
+      @elem = @doc = 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
+    
+    ##
+    # Adds characters to the current element (being parsed)
+    def characters(string)
+      @buffer ||= ""
+      @buffer += 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 no element is being parsed, then, we create a new document, to which we add this new element as root. (we create one document per stanza to avoid memory problems)
+    def start_element(qname, attributes = [])
+      clear_characters_buffer
+      @doc ||= Nokogiri::XML::Document.new
+      @elem ||= @doc # If we have no current element, then, we take the doc
+      @elem = @elem.add_child(Nokogiri::XML::Element.new(qname, @doc))
+      
+      add_namespaces_and_attributes_to_current_node(attributes)
+      
+      if @elem.name == "stream:stream"
+        # We activate the callback since this element  will never end.
+        @callback.call(@elem)
+        @doc = @elem = nil # Let's prepare for the next stanza
+        # And then, we start a new Sax Push Parser
+      end
+    end
+    
+    ##
+    # Clears the characters buffer
+    def clear_characters_buffer
+      if @buffer && @elem
+        @buffer.strip!
+        @elem.add_child(Nokogiri::XML::Text.new(Skates.decode_xml(@buffer), @doc)) unless @buffer.empty?
+        @buffer = nil # empty the buffer
+      end
+    end
+
+    ##
+    # Terminates the current element and calls the callback
+    def end_element(name)
+      clear_characters_buffer
+      if @elem
+        if @elem.parent == @doc
+          # If we're actually finishing the stanza (a stanza is always a document's root)
+          @callback.call(@elem) 
+          # We delete the current element and the doc (1 doc per stanza policy)
+          @elem = @doc = nil 
+        else
+          @elem = @elem.parent 
+        end 
+      else 
+        # Not sure what to do since it seems we're not processing any element at this time, so how can one end?
+      end 
+    end 
+    
+    private
+    
+    ##
+    # Adds namespaces and attributes. Nokogiri passes them as a array of [[ns_name, ns_url], [ns_name, ns_url]..., key, value, key, value]...
+    def add_namespaces_and_attributes_to_current_node(attrs) 
+      # Namespaces
+      attrs.select {|k| k.is_a? Array}.each do |pair|
+        # set_namespace(pair[0], pair[1])
+        set_normal_attribute(pair[0], pair[1])
+      end
+      # Attributes
+      attrs.select {|k| k.is_a? String}.in_groups_of(2) do |pair|
+        set_normal_attribute(pair[0], pair[1])
+      end
+    end
+        
+    def set_normal_attribute(key, value)
+      @elem.set_attribute key, Skates.decode_xml(value)
+    end
+    
+    def set_namespace(key, value)
+      if key.include? ':'
+        @elem.add_namespace(key.split(':').last, value)
+      else
+        @elem.add_namespace(nil, value)
+      end
+    end
+    
+    
+    
+  end 
+end 

data/lib/skates/xpath_helper.rb

@@ -0,0 +1,13 @@
+module Skates
+
+  # 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 do |n|
+        n.name == name && n.namespaces.values.include?(nsuri)
+      end
+    end
+  end
+end

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 Skates::Base::Controller do
+  
+  before(:each) do
+    Skates.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 = Skates::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 = Skates::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 = Skates::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)
+      Skates.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 = Skates::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(Skates::Base::Stanza)
+      @controller = Skates::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 < Skates::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 = Skates::Base::Controller.new()
+    end
+    
+    it "should evaluate the view" do
+      view = mock(Skates::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 = Skates::Base::Controller.new()
+      file_name = "myfile"
+      @controller.__send__(:view_path, file_name).should == File.join("app/views", "#{"Skates::Base::Controller".gsub("Controller","").downcase}", file_name)
+    end
+  end
+  
+  describe ".default_template_name" do
+    before(:each) do
+      @controller = Skates::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 = Skates::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 = Skates::Base::View.new("path_to_a_file", {})
+    end
+    
+    it "should instantiate a new view, with the file provided and the hashed_variables" do
+      Skates::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 Skates::Base::Stanza do
+  
+  describe "initialize" do
+    before(:each) do
+      @stanza_string = "<presence />"
+      @stanza = Skates::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,92 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Skates::Base::View do
+  describe ".initialize" do
+    
+    before(:each) do
+      @view = Skates::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 = Skates::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
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+    end
+        
+    it "should read the template file" do
+      Skates.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
+      Skates.views.stub!(:[]).with(@view_template).and_raise(nil)
+      lambda {
+        @view.evaluate
+      }.should raise_error(Skates::Base::ViewFileNotFound)
+    end
+    
+    it "should return a Nokogiri NodeSet" do
+      Skates.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
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+      @view.should_receive(:eval).with(@xml_string, an_instance_of(Binding), @view_template, 1)
+      @view.evaluate
+    end
+    
+    it "should be able to access context's variables" do
+      @view = Skates::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
+  
+  describe "render" do
+    before(:each) do
+      @view_template = "/a/path/to/a/view/file"
+      @view = Skates::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 |message|
+          message.body("salut") 
+          render(message, {:partial => "partial", :locals => {:subtitle => "bonjour monde"}})
+       end
+      eoxml
+      @partial_string = <<-eoxml
+        xml.title("hello word")
+        xml.subtitle(subtitle)
+      eoxml
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)      
+      Skates.views.stub!(:[]).with("/a/path/to/a/view/partial.xml.builder").and_return(@partial_string)      
+    end
+    
+    it "should render the partial in the right context" do
+      @view.evaluate.xpath("//message/title").text.should == "hello word"
+    end
+    
+    it "should allocate the locals variables" do
+      @view.evaluate.xpath("//message/subtitle").text.should == "bonjour monde"
+    end
+    
+  end
+  
+end