radamanthus-skates 0.3.5

data/lib/skates/ext/array.rb

@@ -0,0 +1,21 @@
+class Array
+  def in_groups_of(number, fill_with = nil)
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat([fill_with] * padding)
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      returning [] do |groups|
+        collection.each_slice(number) { |group| groups << group }
+      end
+    end
+  end
+end

data/lib/skates/generator.rb

@@ -0,0 +1,142 @@
+module Skates
+  module Generator
+    extend Templater::Manifold
+    
+    desc <<-DESC
+      Skates is a framework to generate XMPP Applications in Ruby.
+    DESC
+    
+    ##
+    # Generates a Skates Application
+    class ApplicationGenerator < Templater::Generator
+      desc <<-DESC
+        Generates the file architecture for a Skates 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/skates')
+      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
+      empty_directory :destructors_directory do |d|
+        d.destination = "#{application_name}/config/destructors"
+      end
+      empty_directory :tmp_directory do |d|
+        d.destination = "#{application_name}/tmp"
+      end 
+      empty_directory :log_directory do |d|
+        d.destination = "#{application_name}/log"
+      end
+      empty_directory :pid_directory do |d|
+        d.destination = "#{application_name}/tmp/pids"
+      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
+      template :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: skates 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/skates/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 = "Skates.router.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 < Skates::Base::Stanza" with "class #{action[0]} < Skates::Base::Stanza"
+          content = File.read("app/stanzas/#{action[0]}.rb").gsub("class Stanza < Skates::Base::Stanza", "class #{action[0].capitalize} < Skates::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/skates/router.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__)+"/router/dsl"
+
+module Skates
+  ##
+  # Routers are in charge of sending the right stanzas to the right controllers based on user defined Routes.
+  # Each application can have only one!
+  class StanzaRouter
+    
+    attr_reader :routes, :connection
+    
+    def before_route(&block)
+      @before_route = block
+    end
+    
+    def initialize
+      @routes = []
+    end
+    
+    ##
+    # Connected is called by the XmppConnection to indicate that the XMPP connection has been established
+    def connected(connection)
+      @connection = connection
+    end
+    
+    ##
+    # Look for the first matching route and calls the corresponding action for the corresponding controller.
+    # Sends the response on the XMPP stream/ 
+    # If the before_route callback is defined, it is called.
+    # If the callback returns true, then, the route is NOT executed.
+    # This callback is very useful when an application wants to redirect any stanza it receives before handling it to the routing mechanism.
+    def route(xml_stanza) 
+      abort = if !@before_route.nil?
+        begin
+          @before_route.call(xml_stanza)
+        rescue
+          Skates.logger.info {
+            "Failed to execute before_route callback. Resuming Routing"
+          }
+          false
+        end
+      end
+      if !abort
+        route = routes.select{ |r| r.accepts?(xml_stanza) }.first 
+        return false unless route 
+        execute_route(route.controller, route.action, xml_stanza)
+      else
+        # The callback triggered abortion of teh routing mechanism.
+        return false
+      end
+    end 
+    
+    ##
+    # Executes the route for the given xml_stanza, by instantiating the controller_name, calling action_name and sending 
+    # the result to the connection
+    def execute_route(controller_name, action_name, stanza = nil)
+      begin
+        stanza = Kernel.const_get(action_name.capitalize).new(stanza) if stanza
+        Skates.logger.info {
+          "ROUTING TO #{controller_name}::#{action_name} with #{stanza.class}"
+        }
+      rescue NameError
+        Skates.logger.info {
+          "ROUTING TO #{controller_name}::#{action_name} with #{stanza.class}"
+        }
+      end
+      controller = controller_name.new(stanza) 
+      controller.perform(action_name) 
+      connection.send_xml(controller.evaluate)
+    end
+    
+    ##
+    # Throw away all added routes from this router. Helpful for 
+    # testing. 
+    def purge_routes! 
+      @routes = [] 
+    end 
+    
+    ##
+    # Run the router DSL. 
+    def draw(&block) 
+      dsl = Router::DSL.new 
+      dsl.instance_eval(&block) 
+      dsl.routes.each do |route| 
+        raise("Route lacks destination: #{route.inspect}") unless route.is_a?(Route) 
+      end 
+      @routes += dsl.routes 
+      sort
+    end
+
+    private
+    
+    def sort
+      @routes.sort! { |r1,r2| r2.priority <=> r1.priority }
+    end
+  end
+
+  ##
+  # Route class which associate an XPATH match and a priority to a controller and an action
+  class Route
+    
+    attr_accessor :priority, :controller, :action, :xpath
+    
+    ##
+    # Creates a new route
+    def initialize(params)
+      raise("No controller given for route") unless params["controller"]
+      raise("No action given for route") unless params["action"]
+      raise("No xpath given for route") unless params["xpath"]
+      @priority   = params["priority"] || 0
+      @xpath      = params["xpath"] 
+      @controller = Kernel.const_get("#{params["controller"].capitalize}Controller")
+      @action     = params["action"]
+    end
+    
+    ##
+    # Checks that the route matches the stanzas and calls the the action on the controller.
+    def accepts?(stanza)
+      stanza.xpath(*@xpath).empty? ? false : self
+    end
+    
+  end
+  
+end

data/lib/skates/router/dsl.rb

@@ -0,0 +1,48 @@
+module Skates
+  module Router
+    ##
+    # We use this class to assert the ordering of the router DSL
+    class OutOfOrder < StandardError; end
+
+    # Creates a simple DSL for stanza routing.
+    class DSL
+      attr_reader :routes
+
+      def initialize
+        @routes = []
+      end
+
+      # Match an xpath.
+      def xpath(path, namespaces = {})
+        @routes << {"xpath" => [path, namespaces]}
+        self
+      end
+
+      # Set the priority of the last created route.
+      def priority(n)
+        route = @routes.last
+        raise OutOfOrder unless route.is_a?(Route) # check that this is in the right order
+        route.priority = n
+        self
+      end
+
+      # Map a route to a specific controller and action.
+      def to(params)
+        last = @routes.pop
+        last["controller"] = params[:controller]
+        last["action"] = params[:action]
+        # We now have all the properties we really need to create a route.
+        @routes << Route.new(last)
+        self
+      end
+
+      protected
+      def disco_for(type, node = nil)
+        str = "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco##{type.to_s}')"
+        str << " and @node = '#{node}'" if node
+        str << "]"
+        xpath(str)
+      end
+    end
+  end
+end

data/lib/skates/runner.rb

@@ -0,0 +1,164 @@
+module Skates
+  
+  ##
+  # Runner is in charge of running the application.
+  class Runner
+    
+    PHI = ((1+Math.sqrt(5))/2.0)
+    
+    ## 
+    # Prepares the Application to run.
+    def self.prepare(env)
+      # Load the configuration
+      Skates.config = YAML.load_file(Skates.config_file)[Skates.environment]
+      
+      Skates.reopen_logs
+      
+      # Requiring all models, stanza, controllers
+      ['app/models/*.rb', 'app/stanzas/*.rb', 'app/controllers/*_controller.rb'].each do |dir|
+        Runner.require_directory(dir)
+      end
+      
+      # Create the router
+      Skates.router = Skates::StanzaRouter.new
+      
+      # Evaluate routes defined with the new DSL router.
+      require 'config/routes.rb'
+            
+      # Caching views
+      Skates.cache_views
+      
+      #Setting failed connection attemts
+      @failed_connections = 0
+      
+    end
+    
+    ##
+    # Convenience method to require files in a given directory
+    def self.require_directory(path)
+      Dir.glob(path).each { |f| require f }
+    end
+    
+    ##
+    # When run is called, it loads the configuration, the routes and add them into the router
+    # It then loads the models.
+    # Finally it starts the EventMachine and connect the ComponentConnection
+    # You can pass an additional block that will be called upon launching, when the eventmachine has been started.
+    def self.run(env)
+      
+      Skates.environment = env
+      
+      # Starting the EventMachine
+      EventMachine.epoll
+      EventMachine.run do
+        
+        Runner.prepare(env)
+        
+        case Skates.config["application_type"] 
+        when "client"
+          Skates::ClientConnection.connect(Skates.config, self) 
+        else # By default, we assume it's a component
+          Skates::ComponentConnection.connect(Skates.config, self) 
+        end
+        
+        # And finally, let's allow the application to do all it wants to do after we started the EventMachine!
+        yield(self) if block_given?
+      end
+    end
+    
+    ##
+    # Returns the list of connection observers
+    def self.connection_observers()
+      @@observers ||= Array.new
+    end
+    
+    ##
+    # Adding a connection observer. These observer will receive on_connected and on_disconnected events.
+    def self.add_connection_observer(observer)
+      @@observers ||= Array.new 
+      if observer.ancestors.include? Skates::Base::Controller
+        Skates.logger.debug {
+          "Added #{observer} to the list of Connection Observers"
+        }
+        @@observers.push(observer) unless @@observers.include? observer
+      else
+        Skates.logger.error {
+          "Observer can only be Skates::Base::Controller"
+        }
+        false
+      end
+    end
+    
+    ## 
+    # Will be called by the connection class once it is connected to the server.
+    # It "plugs" the router and then calls on_connected on the various observers.
+    def self.on_connected(connection)
+      Skates.router.connected(connection)
+      connection_observers.each do |observer|
+        Skates.router.execute_route(observer, "on_connected")
+      end
+      
+      # Connected so reset failed connection attempts
+      @failed_connections = 0
+    end
+    
+    ##
+    # Will be called by the connection class upon disconnection.
+    # It stops the event loop and then calls on_disconnected on the various observers.
+    def self.on_disconnected()
+      connection_observers.each do |conn_obs|
+        observer = conn_obs.new
+        observer.on_disconnected if observer.respond_to?("on_disconnected")
+      end
+      
+      if Skates.config["auto-reconnect"]
+        # Increment failed connection attempts and calculate time to next re-connect
+        @failed_connections += 1
+        reconnect_in = fib(@failed_connections)
+      
+        EventMachine.add_timer( reconnect_in ) {reconnect} if EM.reactor_running?
+      
+        Skates.logger.error {
+          "Disconnected - trying to reconnect in #{reconnect_in} seconds."
+        }
+      else
+        EM.stop_event_loop
+      end
+    end
+    
+    ##
+    # Will be called by the connection class when it receives and parses a stanza.
+    def self.on_stanza(stanza)
+      begin
+        Skates.router.route(stanza)
+      rescue Skates::NotConnected
+        Skates.logger.fatal {
+          "#{$!.class} => #{$!.inspect}\n#{$!.backtrace.join("\n")}"
+        }
+        EventMachine::stop_event_loop
+      rescue
+        Skates.logger.error {
+          "#{$!.class} => #{$!.inspect}\n#{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+    
+    ##
+    # Tries to reconnect
+    def self.reconnect
+      #Try to reconnect
+      case Skates.config["application_type"] 
+      when "client"
+        Skates::ClientConnection.connect(Skates.config, self) 
+      else # By default, we assume it's a component
+        Skates::ComponentConnection.connect(Skates.config, self) 
+      end
+    end
+    
+    ##
+    # Helper to calculate the fibonnacci number.
+    def self.fib(n)
+      (Skates::Runner::PHI**n).round
+    end
+  end
+end