radamanthus-skates 0.3.5

data/lib/skates/xmpp_connection.rb

@@ -0,0 +1,216 @@
+module Skates
+  
+  ## 
+  # Connection Exception
+  class NotConnected < StandardError; end
+
+  ## 
+  # xml-not-well-formed Exception
+  class XmlNotWellFormed < StandardError; end
+
+  ##
+  # Error when there is no connection to the host and port.
+  class NoConnection < StandardError; end
+
+  ##
+  # Authentication Error (wrong password/jid combination). Used for Clients and Components
+  class AuthenticationError < StandardError; end
+
+  ##
+  # Raised when the application tries to send a stanza that might be rejected by the server because it's too long.
+  class StanzaTooBig < StandardError; end
+
+  ##
+  # This class is in charge of handling the network connection to the XMPP server.
+  class XmppConnection < EventMachine::Connection
+    
+    attr_accessor :jid, :host, :port
+    
+    @@max_stanza_size = 65535
+    
+    ##
+    # This will the host asynscrhonously and calls the block for each IP:Port pair.
+    # if the block returns true, no other record will be tried. If it returns false, the block will be called with the next pair.
+    def self.resolve(host, &block)
+      block.call(false)
+    end
+    
+    ##
+    # Maximum Stanza size. Default is 65535
+    def self.max_stanza_size
+      @@max_stanza_size
+    end
+    
+    ##
+    # Setter for Maximum Stanza size.
+    def self.max_stanza_size=(_size)
+      @@max_stanza_size = _size
+    end
+
+    ##
+    # Connects the XmppConnection to the right host with the right port.
+    # It passes itself (as handler) and the configuration
+    # This can very well be overwritten by subclasses.
+    def self.connect(params, handler)
+      if params["host"] =~ /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/ 
+        params["port"] = params["port"] ? params["port"].to_i : 5222 
+        _connect(params, handler)
+      else
+        resolve(params["host"]) do |host_info|
+          if host_info
+            begin
+              _connect(params.merge(host_info), handler)
+              true # connected! Yay!
+            rescue NotConnected
+              # It will try the next pair of ip/port
+              false
+            end
+          else
+            Skates.logger.error {
+              "Sorry, we couldn't resolve #{srv_for_host(params["host"])} to any host that accept XMPP connections. Please provide a params[\"host\"]."
+            }
+            EM.stop_event_loop
+          end
+        end
+      end
+    end
+
+    ##
+    # Called when the connection is completed.
+    def connection_completed
+      @connected = true
+      Skates.logger.debug {
+        "CONNECTED"
+      } # Very low level Logging
+    end
+
+    ##
+    # Called when the connection is terminated and stops the event loop
+    def unbind()
+      @connected = false
+      Skates.logger.debug {
+        "DISCONNECTED"
+      } # Very low level Logging
+      begin
+        @handler.on_disconnected() if @handler and @handler.respond_to?("on_disconnected")
+      rescue
+        Skates.logger.error {
+          "on_disconnected failed : #{$!}\n#{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+
+    ## 
+    # Instantiate the Handler (called internally by EventMachine)
+    def initialize(params = {})
+      @connected = false
+      @jid       = params["jid"]
+      @password  = params["password"]
+      @host      = params["host"]
+      @port      = params["port"]
+      @handler   = params["handler"]
+      @buffer    = "" 
+    end
+    
+    ##
+    # Attaches a new parser since the network connection has been established.
+    def post_init
+      @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.
+    def receive_stanza(stanza)
+      Skates.logger.debug {
+        "PARSED : #{stanza.to_xml}"
+      }
+      # If not handled by subclass (for authentication)
+      case stanza.name
+      when "stream:error"
+        if !stanza.children.empty? and stanza.children.first.name == "xml-not-well-formed"
+          Skates.logger.error {
+            "DISCONNECTED DUE TO MALFORMED STANZA"
+          }
+          raise XmlNotWellFormed
+        end
+        # In any case, we need to close the connection.
+        close_connection
+      else
+        begin
+          @handler.on_stanza(stanza) if @handler and @handler.respond_to?("on_stanza")
+        rescue
+          Skates.logger.error {
+            "on_stanza failed : #{$!}\n#{$!.backtrace.join("\n")}"
+          }
+        end
+      end 
+    end 
+
+    ## 
+    # Sends the Nokogiri::XML data (after converting to string) on the stream. Eventually it displays this data for debugging purposes.
+    def send_xml(xml)
+      begin
+        if xml.is_a? Nokogiri::XML::NodeSet
+          xml.each do |element|
+            send_chunk(element.to_s)
+          end
+        else
+          send_chunk(xml.to_s)
+        end
+      rescue
+        Skates.logger.error {
+          "SENDING FAILED: #{$!}"
+        }
+      end
+    end
+    
+    private
+    
+    def send_chunk(string = "")
+      raise NotConnected unless @connected
+      return if string == ""
+      raise StanzaTooBig, "Stanza Too Big (#{string.length} vs. #{XmppConnection.max_stanza_size})\n #{string}" if string.length > XmppConnection.max_stanza_size
+      Skates.logger.debug {
+        "SENDING : " + string
+      }
+      send_data UTF8Cleaner.clean(string)
+    end
+
+    ## 
+    # receive_data is called when data is received. It is then passed to the parser. 
+    def receive_data(data)
+      data = UTF8Cleaner.clean(data)
+      begin
+        Skates.logger.debug {
+          "RECEIVED : #{data}"
+        }
+        @parser.push(data) 
+      rescue
+        Skates.logger.error {
+          "#{$!}\n#{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+  
+    def self.srv_for_host(host)
+      "#{host}"
+    end
+  
+    def self._connect(params, handler)
+      Skates.logger.debug {
+        "CONNECTING TO #{params["host"]}:#{params["port"]} with #{handler.inspect} as connection handler" # Very low level Logging
+      }
+      begin
+        EventMachine.connect(params["host"], params["port"], self, params.merge({"handler" => handler}))
+      rescue RuntimeError
+        Skates.logger.error {
+          "CONNECTION ERROR : #{$!.class} => #{$!}" # Very low level Logging
+        }
+        raise NotConnected
+      end
+      
+    end
+    
+  end
+
+end

data/lib/skates/xmpp_parser.rb

@@ -0,0 +1,112 @@
+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(@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 
+    
+    ##
+    # 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/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/skates/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