waw 0.2.2

data/lib/waw/controllers/action/action_utils.rb

@@ -0,0 +1,30 @@
+module Waw
+  class ActionController < Waw::Controller
+    #
+    # Common utilities about actions.
+    #
+    module ActionUtils
+      
+      # Extracts the action name from a given path
+      def extract_action_name(path)
+        return $1.to_sym if path =~ /([a-zA-Z_]+)$/
+        nil
+      end
+    
+      # Checks if an action exists
+      def has_action?(name)
+        name = extract_action_name(name) unless Symbol===name
+        return false unless name
+        actions.has_key?(name)
+      end
+      
+      def find_action(name)
+        name = extract_action_name(name) unless Symbol===name
+        return nil unless name
+        actions[name]
+      end
+      alias :[] :find_action
+      
+    end # module ActionUtils
+  end # class ActionController
+end # module Waw

data/lib/waw/controllers/action/js_generation.rb

@@ -0,0 +1,116 @@
+module Waw
+  class ActionController < ::Waw::Controller
+    class JSGeneration
+      
+      # Header of the generated javascript file
+      HEADER = <<-EOF
+        /* This file is automatically generated by Waw. Any edit will probably be lost
+         * next time the application is started. */
+      EOF
+      
+      # Strip n spaces at the begining of a string
+      def strip(str, n)
+        str.gsub(/\t/, "  ").gsub(/^\s{#{n}}/, '')
+      end
+      
+      # Raises a ConfigurationError
+      def error(msg)
+        raise ConfigurationError, msg
+      end
+      
+      # Start hook start callback required by Waw. Generates the javascript code
+      # if the configuration variable 'code_at_startup' is true. 
+      def run(waw_kernel)
+        return unless waw_kernel.config.code_at_startup
+        
+        # Now, find the StaticController, that should be installed
+        static = waw_kernel.find_rack_app {|app| ::Waw::StaticController===app}
+        error("Code generation expects a ::Waw::StaticController being installed.") if static.nil?
+        
+        # Find the folder now
+        folder = File.join(waw_kernel.root_folder, static.public_folder, 'js')
+        error("Code generation expects #{folder} to be an existing directory.") unless File.directory?(folder)
+        
+        # Look for the application name
+        appname = waw_kernel.config.knows?(:application_name) ? waw_kernel.config.application_name : 'waw'
+        
+        # And let's go now!
+        file = File.join(folder, "#{appname}_generated.js")
+        File.open(file, 'w') do |buffer|
+          generate_js(waw_kernel, buffer)
+        end
+      end  
+      
+      # Generate the javascript code for installed action controllers.
+      def generate_js(waw_kernel, buffer)
+        # 1) header first
+        buffer << strip(HEADER, 8) << "\n"
+        
+        # 2) messages
+        generate_js_messages(waw_kernel, buffer)
+        
+        # 3) controllers
+        generate_js_controllers(waw_kernel, buffer)
+      end
+    
+      # Generates the javascript code for message resources.
+      def generate_js_messages(waw_kernel, buffer)
+        if waw_kernel.resources.has_resource?(:messages)
+          buffer << "/* Messages, from waw.resources.messages */\n"
+          messages = {}
+          waw_kernel.resources.messages.each do |name, value|
+            messages[name] = value 
+          end  
+          buffer << "var messages = new Array();\n"
+          messages.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}.each do |name|
+            value = messages[name]
+            buffer << "messages['#{name}'] = \"#{value}\";\n"    
+          end
+          buffer << "\n"
+        end
+      end
+      
+      # Generates the js controllers
+      def generate_js_controllers(waw_kernel, buffer)
+        ActionController.controllers.sort{|c1, c2| c1.class.name <=> c2.class.name}.each do |controller|
+          # Let find the URL for this controller
+          app = waw_kernel.find_rack_app{|a| controller===a}
+          url = app ? app.find_url_of(app) : nil
+          unless url
+            waw_kernel.logger.warn("Skipping #{controller}, which does not seem to be mapped to an URL")
+          else
+            header = <<-EOF
+              /* Actions contributed by #{controller}, mapped to #{url} */
+            EOF
+            buffer << strip(header, 14)
+            controller.actions.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}.each do |name|
+              action = controller.actions[name]
+              generate_js_for_action(waw_kernel, action, buffer)
+            end
+          end
+        end
+      end
+    
+      # Generates the javascript code for a given action
+      def generate_js_for_action(waw_kernel, action, buffer)
+        action_js = <<-THEEND
+          function #{action.id}(request_data, form) {
+            $.ajax({type: "POST", url: "#{action.url}", data: request_data, dataType: "json",
+              error: function(data) {
+          		  window.location = '/feedback?mkey=server_error';
+          		},
+          		success: function(data) {
+        THEEND
+        action_js << action.routing.generate_js_routing(action, 0).gsub(/^/, " "*16) << "\n"
+        action_js << <<-THEEND
+          		}
+          	});
+          	return false;
+          }  
+        THEEND
+        buffer << strip(action_js, 10)
+      end
+      
+    end # class JSGeneration
+  end # class ActionController
+end # module Waw

data/lib/waw/controllers/action_controller.rb

@@ -0,0 +1,133 @@
+require 'waw/controllers/action/action_utils'
+require 'waw/controllers/action/action'
+require 'waw/controllers/action/js_generation'
+module Waw
+  
+  # 
+  # Defines a specific application controller for executing actions.
+  #
+  class ActionController < Waw::Controller
+    include ActionUtils
+    extend FullState::OnClass
+    extend FullState::OnInstance
+    
+    # All subclasses
+    @@controllers = []
+    
+    class << self
+
+      # Returns known controllers
+      def controllers
+        @@controllers
+      end
+        
+      # When this class is inherited we track the new controller, it becomes a 
+      # Singleton and we install code generation as start hook if not already done.
+      def inherited(child)
+        super(child)
+        # Adds the controller as a child
+        controllers << child
+        
+        # Let it become a singleton
+        child.instance_eval { include Singleton }
+        
+        # And install start hook for code generation
+        if controllers.size==1 && (k = Waw.kernel)
+          k.add_start_hook(JSGeneration.new) 
+          k.add_unload_hook ::Kernel.lambda { @@controllers = [] }
+        end
+      end
+
+    end
+
+    # This is all about actions 
+    class << self
+      include ActionUtils
+      
+      # Returns the url on which this controller is mapped
+      def url
+        self.instance.url
+      end
+    
+      # Returns installed actions
+      def actions
+        @actions ||= {}
+      end
+      
+      # Fired when a signature will be next installed
+      def signature(signature=nil, &block)
+        signature = (signature.nil? ? Waw::Validation::Signature.new : signature)
+        signature = signature.merge(&block) if block
+        @signature = signature
+      end
+      
+      # Installs a routing block for the next action
+      def routing(&block)
+        @routing = Waw::Routing::ActionRouting.new(&block)
+      end
+      
+      # If a signature has been installed, let the next added method
+      # become an action
+      def method_added(name)
+        if @signature and not(@critical)
+          @critical = true
+      
+          # Create the action instance
+          action = Waw::ActionController::Action.new(name, @signature, @routing, self, instance_method(name))
+          actions[name] = action
+          
+          # Installs the class method that returns the action
+          instance_eval <<-EOF
+            class << self
+              def #{name}
+                actions[:#{name}]
+              end
+            end
+          EOF
+          
+          # Installs the instance method that execute the action
+          define_method name do |params|
+            action.execute(params)
+          end 
+        end
+        @signature, @routing, @critical = nil, nil, false
+      end
+      
+    end # end of class methods
+    
+    # Returns the url on which this controller is mapped
+    def url
+      find_kernel_context.find_url_of(self)
+    end
+    
+    # Returns the actions installed on this controller
+    def actions
+      self.class.actions
+    end
+    
+    # Ensapsules the action call 
+    def encapsulate(action, actual_params, &block)
+      yield
+    end
+    
+    # Executes the controller
+    def execute(env, request, response)
+      action_name = request.respond_to?(:path) ? request.path : request[:action]
+      logger.debug("Executing the action whose name is #{action_name}")
+      action = find_action(action_name)
+      if action
+        actual_params = request.params.symbolize_keys
+        result = encapsulate(action, actual_params) do 
+          action.execute(actual_params)
+        end
+        logger.debug("ActionResult is #{result.inspect}")
+        [200, {}, result]
+      else
+        logger.warn("Action #{action_name} has not been found")
+        [200, {}, [:error, :action_not_found]]
+      end
+    end
+  
+  end # class ActionController
+
+end # module Waw 

data/lib/waw/controllers/error/backtrace.rb

@@ -0,0 +1,54 @@
+require 'cgi'
+module Waw
+  class ErrorHandler < ::Waw::Controller
+    class Backtrace
+      
+      # Converts a back-trace to a friendly HTML chunck
+      def ex_backtrace_to_html(backtrace)
+        "<div>" + backtrace.collect{|s| CGI.escapeHTML(s)}.join('</div><div>') + "</div>"
+      end
+    
+      # Converts an exception to a friendly HTML chunck
+      def ex_to_html(ex, backtrace)
+        <<-EOF
+          <html>
+            <head>
+              <style type="text/css">
+                body {
+                  font-size: 14px;
+                	font-family: "Courier", "Arial", sans-serif;
+                }
+                p.message {
+                  font-size: 16px;
+                  font-weight: bold;
+                }
+              </style>
+            </head>
+            <body>
+              <h1>Internal server error (ruby exception)</h1>
+              <p class="message"><code>#{CGI.escapeHTML(ex.message)}</code></p>
+              <div style="margin-left:50px;">
+                #{ex_backtrace_to_html(backtrace)}
+              </div>
+            </body>
+          </html>
+        EOF
+      end
+      
+      # Shows a page with a friendly presented backtrace for the error
+      # that occured
+      def call(kernel, ex)
+        backtrace = case ex
+          when ::WLang::Error
+            ex.wlang_backtrace
+          when ::Exception
+            ex.backtrace
+          else 
+            []
+        end
+        [500, {'Content-Type' => 'text/html'}, ex_to_html(ex, backtrace)]
+      end
+      
+    end # class Backtrace
+  end # module ErrorHandler
+end # module Waw

data/lib/waw/controllers/error_handler.rb

@@ -0,0 +1,62 @@
+require 'waw/controllers/error/backtrace'
+module Waw
+  class ErrorHandler < ::Waw::Controller
+    
+    # Creates an error handler rack application
+    def initialize(app)
+      @app = app
+      @validators, @handlers = [], []
+    end
+    
+    # Handles arguments of push and unshift
+    def handle_args(args, &block)
+      validator, handler = args
+      handler = block if handler.nil?
+      validator, handler = nil, validator if handler.nil?
+      [validator, handler]
+    end
+    
+    # Adds an error handler. The method accepts the following 
+    # argument variants:
+    #
+    #   add_error_handler{|k,ex| ... }
+    #   add_error_handler(SomeValidator){|k,ex| ... }
+    #   add_error_handler(SomeHandler)
+    #   add_error_handler(SomeValidator, SomeHandler)
+    #
+    def add_error_handler(*args, &block)
+      validator, handler = handle_args(args, &block)
+      @validators << validator
+      @handlers << handler
+    end
+    alias :push :add_error_handler 
+    
+    # Same as add_error_handler but adds it at the begining of the 
+    # chain
+    def unshift(*args, &block)
+      validator, handler = handle_args(args, &block)
+      @validators.unshift(validator)
+      @handlers.unshift(handler)
+    end
+    
+    # Checks if a result seems a valid rack application result
+    def seems_valid_result?(result)
+      not(result.nil?) and Array===result and result.size==3
+    end
+    
+    # Handles a call
+    def call(env)
+      @app.call(env)
+    rescue Exception => ex
+      kernel = find_kernel_context
+      @validators.each_with_index do |validator, i|
+        if (validator.nil? or (validator===ex))
+          result = @handlers[i].call(kernel, ex)
+          return result if seems_valid_result?(result)
+        end
+      end
+      raise ex
+    end
+    
+  end # class ErrorHandler
+end # module Waw

data/lib/waw/controllers/json_controller.rb

@@ -0,0 +1,31 @@
+require 'json'
+module Waw
+  #
+  # Decorates a given controller and convert result as JSON unless stated
+  # otherwise.
+  #
+  class JSONController
+    include ::Rack::Delegator
+
+    # Creates a controller instance
+    def initialize(app)
+      raise WAWError, "JSONController expects a delegation controller" if app.nil?
+      @app = app
+    end
+
+    # Calls the delegation controller and encode its result in JSON
+    def call(env)
+      status, headers, body = @app.call(env)
+      header = {} if headers.nil?
+      headers['Content-Type'] = 'application/json' if headers['Content-Type'].nil? 
+      body = ::JSON.generate(body) if json_response?(headers)
+      [status, headers, body]
+    end
+
+    # Do i need to encode as JSON?
+    def json_response?(headers)
+      (headers['Content-Type'] == 'application/json')
+    end
+
+  end # class JSONController
+end # module Waw

data/lib/waw/controllers/no_cache.rb

@@ -0,0 +1,22 @@
+require 'time'
+module Waw
+  class NoCache < ::Waw::Controller
+    
+    # What is sent to the headers
+    NO_CACHE_HEADERS = {'Cache-control' => "no-store, no-cache, must-revalidate", 
+                        'Pragma'        => "no-cache"}
+    
+    # Creates a application instance
+    def initialize(app)
+      @app = app
+    end
+    
+    # Manage calls
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = NO_CACHE_HEADERS.merge('Expires' => Time.now.rfc2822).merge(headers)
+      [status, headers, body]
+    end
+    
+  end # class NoCache
+end # module Waw