mentawai 0.5.0 → 0.6.0

data/lib/mentawai/core/app_manager.rb

@@ -5,17 +5,19 @@ module Mentawai
   
     class ApplicationManager
 
-      def initialize
+      def initialize(app)
         
         puts "Initializing application manager..."
         
+        @app = app
+        
         @actions = Hash.new
         @innerActions = Hash.new
         
         @globalFilters = Array.new
         @globalConsequences = Hash.new
         
-        @loader = Loader.new('./actions')
+        @loader = Loader.new(".#{app.contextPathDir}/WEB-INF")
         @loader.reloadFiles
         
         @pageMethods = initPageMethods
@@ -26,6 +28,10 @@ module Mentawai
         # should be overriden...
       end
       
+      def app
+        @app
+      end
+      
       def pageMethods
         @pageMethods
       end
@@ -44,9 +50,20 @@ module Mentawai
         @customPageMethods
       end
       
-      def action(className, actionName = nil, innerAction = nil)
-        ac = ActionConfig.new(className, actionName, innerAction)
-        addActionConfig(ac)
+      def action(params)
+        if params.is_a?(Hash)
+          class_name = params[:class_name]; raise "class_name is required!" if not class_name
+          action_name = params[:action_name]; action_name.sub!(/^\//, "") if action_name
+          inner_action = params[:inner_action]
+          ac = ActionConfig.new(class_name, action_name, inner_action)
+          addActionConfig(ac)
+        elsif params.is_a?(String)
+          class_name = params
+          ac = ActionConfig.new(class_name)
+          addActionConfig(ac)
+        else
+          raise "Invalid arguments to create action config!"
+        end
       end
       
       def addActionConfig(ac)
@@ -90,7 +107,8 @@ module Mentawai
         else
           map = @innerActions[actionName]
           if map == nil
-            nil
+            # Use consequences from regular action
+            @actions[actionName]
           else
             map[innerAction]
           end
@@ -98,11 +116,32 @@ module Mentawai
       end
     end
     
+    # Methods to create consequences...
+    
+    def fwd(page)
+      Forward.new(app.contextPathDir, page)
+    end
+    
     private
     
     def initPageMethods
       h = Hash.new
       h[:m_out] = [ 'Mentawai::Page::Method::Out', 'print' ]
+      h[:m_content_type] = [ 'Mentawai::Page::Method::ContentType', 'set_content_type' ]
+      
+      # Message, Error and Field Error
+      
+      h[:m_has_errors]    = %w{ Mentawai::Page::Method::Message hasErrors }
+      h[:m_has_error]     = %w{ Mentawai::Page::Method::Message hasError }
+      h[:m_has_msgs]      = %w{ Mentawai::Page::Method::Message hasMessages }
+      h[:m_has_msg]       = h[:m_has_msgs]
+      h[:m_errors]        = %w{ Mentawai::Page::Method::Message errors }
+      h[:m_error]         = %w{ Mentawai::Page::Method::Message error }
+      h[:m_msgs]          = %w{ Mentawai::Page::Method::Message messages }
+      h[:m_msg]           = %w{ Mentawai::Page::Method::Message message }
+      h[:m_field_errors]  = %w{ Mentawai::Page::Method::Message fieldErrors }
+      
+      # Don't forget to return this
       h
     end
     

data/lib/mentawai/core/controller.rb

@@ -1,4 +1,7 @@
 require 'monitor'
+require 'mentawai/i18n/loc_manager'
+
+include Mentawai::I18N
 
 module Mentawai
   module Core
@@ -8,13 +11,20 @@ module Mentawai
       @@forward_cache = Hash.new
       @@forward_cache.extend(MonitorMixin)
       
-      def initialize(contextPath, appContext, appManager)
-        @contextPath = contextPath
-        @appContext = appContext
-        @appManager = appManager
+      def initialize(app)
+        @contextPath = app.contextPath
+        @appContext = app.appContext
+        @appManager = app.appManager
+        @extension = app.extension
+        @consequence = nil
+        @action = nil
       end
       
-      attr_reader :appManager, :action, :contextPath
+      attr_reader :appManager, :contextPath, :extension
+      
+      def action
+        @action
+      end
       
       def output
         @action.output
@@ -44,21 +54,26 @@ module Mentawai
         @action.page
       end
       
+      def consequence
+        @consequence
+      end
+      
       def service(env, req, res)
         
         url = req.fullpath.dup
         
         # Check if we are directly acessing a
         # static page instead of an action
-        if url =~ /\.(\w{1,4})$/ then
-          if Forward.types.key?($1) then
-            return service_direct(env, req, res)
-          end
+        # By the time we get here, this can only be a mentawai action
+        # or a forward to a dynamic page such as ERB.
+        # (see MentaHandler to understand how it works!)
+        unless url =~ /\.#{extension}\??$/ or url =~ /\.#{extension}\?.+$/
+          return service_direct(env, req, res)
         end
         
         fix_url(url)
         
-        url.gsub!(/\.\w{1,4}$/, "") # remote any extension (max 4 chars)
+        url.gsub!(/\.\w+$/, "") # remote any extension
     
         actionName = nil    
         innerAction = nil
@@ -73,7 +88,7 @@ module Mentawai
         @appManager.reloadActions
         
         ac = @appManager.getActionConfig(actionName, innerAction)
-
+        
         if ac then
           @action = eval("#{ac.className}.new")
         else
@@ -93,28 +108,34 @@ module Mentawai
         
         conseq = nil
         
+        # Action specific consequence...
         conseq = ac.getConsequence(result) if ac
         
+        # Global consequence...
         conseq = @appManager.getConsequence(result) if not conseq
         
         if not conseq then
           
           # Use conventions to find a view
-          dest = actionName + "/" + (innerAction ? innerAction : 'index') + '.erb'
+          dest = '/' + actionName + "/" + (innerAction ? innerAction : 'index') + '.erb'
+          
+          full_dest = @appManager.app.contextPathDir + dest
           
           # Cache forward consequence...
           @@forward_cache.synchronize {
-            conseq = @@forward_cache[dest]
+            conseq = @@forward_cache[full_dest]
             if not conseq then
               # Check if file exists
-              if File.exists?("./views/" + dest) then
-                @@forward_cache[dest] = conseq = Forward.new(dest)
+              if File.exists?('.' + full_dest) then
+                @@forward_cache[full_dest] = conseq = Forward.new(@appManager.app.contextPathDir, dest)
               end
             end
           }
         end
 
-        raise "Cannot find consequence! action=#{actionName} inner=#{innerAction ? innerAction : 'nil'}" if not conseq
+        raise "Cannot find consequence! result=#{result} action=#{actionName} inner=#{innerAction ? innerAction : 'nil'}" if not conseq
+        
+        @consequence = conseq
         
         conseq.exec(self, req, res, @action)
         
@@ -124,6 +145,8 @@ module Mentawai
         
         # Accessing a page file directly
         
+        full_url = @appManager.app.contextPathDir + req.fullpath
+        
         url = req.fullpath.dup
         
         fix_url(url)
@@ -136,10 +159,12 @@ module Mentawai
         
         # Cache forward consequence...
         @@forward_cache.synchronize {
-          forward = @@forward_cache[url]
-          @@forward_cache[url] = forward = Forward.new(url) if not forward
+          forward = @@forward_cache[full_url]
+          @@forward_cache[full_url] = forward = Forward.new(@appManager.app.contextPathDir, url) if not forward
         }
         
+        @consequence = forward
+        
         forward.exec(self, req, res, @action)
         
       end
@@ -166,6 +191,8 @@ module Mentawai
           action.cookies = c
           action.application = @appContext
           action.page = Hash.new
+          locales = get_locales(request.env['HTTP_ACCEPT_LANGUAGE'])
+          action.locale = LocaleManager.instance.get(locales)
         else
           raise "Not an action: " + action.to_s
         end
@@ -174,6 +201,15 @@ module Mentawai
     
     private
     
+    def get_locales(langs)
+      return nil if langs.nil?
+      locs = langs.split(/\s*,\s*/)
+      locs.collect! do |x|
+        x.split(/\s*\;\s*/)[0]
+      end
+      locs
+    end
+    
     def exec_page_method(className, methodName, args)
       if args.length <= 0 then
         m = eval(className + ".new(self, nil)")  
@@ -184,7 +220,7 @@ module Mentawai
     end
     
     def method_missing(id, *args)
-      
+
       # Crazy bug: method_missing is being called for everything
       # and not just for controller. Make a crazy call inside
       # an action an you will see;

data/lib/mentawai/core/forward.rb

@@ -6,26 +6,40 @@ module Mentawai
   
     class Forward
       
-      DEFAULT_TYPE = 'text/html'
-      
       @@types = Hash.new
-      @@types['erb'] = 'text/html'
-      @@types['txt'] = 'text/plain'
-      @@types['xml'] = 'text/xml'
+      @@types['.erb'] = 'text/html'
+      
+      def self.add_extension(extension, default_mime_type = "text/html")
+        @@types[extension] = default_mime_type
+      end
       
-      def self.types
-        @@types
+      def self.is_registered?(extension)
+        @@types.key?(extension)
       end
     
-      def initialize(page)
+      def initialize(context_path_dir, page)
         @page = page
-        if page =~ /\.(\w+)$/ then
-          @contentType = @@types[$1] || DEFAULT_TYPE
+        
+        extension = nil
+        
+        if page =~ /(\.\w+)$/ then
+          extension = $1
+        end
+        
+        if not extension or not @@types.key?(extension)
+          raise "File extension not supported: #{page}"
+        end
+        
+        @contentType = @@types[extension]
+        
+        if page !~ /^\//
+          @filename = ".#{context_path_dir}/#{page}"
         else
-          @contentType = DEFAULT_TYPE
+          @filename = ".#{context_path_dir}#{page}"
         end
-        @filename = './views/' + page
-        raise "Cannot find page: " + page if not File.exists?(@filename)
+        
+        raise "Cannot find page: " + @filename if not File.exists?(@filename)
+        
         @file = File.new(@filename)
         @lastmodified = @file.mtime
         input = File.read(@filename)
@@ -33,6 +47,10 @@ module Mentawai
         @lock = Mutex.new
       end
       
+      def content_type=(type)
+        @contentType = type
+      end
+      
       def exec(controller, req, res, action)
         @lock.synchronize {
           if @lastmodified != @file.mtime then

data/lib/mentawai/core/input.rb

@@ -15,7 +15,7 @@ module Mentawai
         # Copy headers...
         @headers = Hash.new
         req.env.each do |k,v|
-          @headers[k] = v if k =~ /^[A-Z]/ # Begin with capital
+          @headers[k] = v if k =~ /^HTTP_/ # Begin with HTTP
         end
       end
         
@@ -36,9 +36,7 @@ module Mentawai
       end
         
       def headers
-        @headers.each do |k,v|
-          yield k
-        end
+        @headers
       end
     
       def keys
@@ -72,11 +70,13 @@ module Mentawai
       alias hasProp? hasProperty?
       
       def getProperty(prop)
-        @request.class.public_instance_methods.each do |m|
-          if m == prop then
-            return @request.send(prop)
-          end
-        end
+        # Try env...
+        return @request.env[prop] if @request.env.key?(prop)
+        
+        # Capitalize?
+        return @request.env[prop.upcase] if @request.env.key?(prop.upcase)
+        
+        # Nothing found...
         nil
       end
       

data/lib/mentawai/handler/menta_handler.rb

@@ -0,0 +1,178 @@
+require 'rack'
+require 'mongrel/handlers'
+
+module Mentawai
+  module Handler
+    
+    class MentaHandler < Rack::Handler::Mongrel
+      
+      def initialize(server, app)
+        
+        @server = server
+        
+        listing_allowed = false
+        
+        # Check if any application has listing turned on...
+        @server.apps.each do |k,v|
+          if v.listing_allowed
+            listing_allowed = true
+            break
+          end
+        end
+        
+        @dir_handler = Mongrel::DirHandler.new('.', listing_allowed)
+        
+        super app
+      end
+      
+      def self.mime_types
+        Mongrel::DirHandler.const_get(:MIME_TYPES)
+      end
+      
+      def self.add_mime_type(extension, type)
+        mime_types[extension] = type
+      end
+      
+      def self.run(menta_server, app, options={})
+        server = ::Mongrel::HttpServer.new(options[:Host] || '0.0.0.0', options[:Port] || 8080)
+        server.register('/', MentaHandler.new(menta_server, app))
+        yield server  if block_given?
+        server.run.join
+      end
+      
+      def process(request, response)
+        
+        env = {}.replace(request.params)
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+        env["QUERY_STRING"] ||= ""
+        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+        
+        req = Rack::Request.new(env)
+
+        url = req.fullpath
+        
+        context_path = @server.find_context_path(url)
+        
+        app = @server.apps[context_path]
+        
+        context_path_dir = app.contextPathDir
+
+        ru = RequestURL.new(context_path, context_path_dir, url, app.default_page)
+        
+        # Block forbidden directory...
+        if ru.forbidden? then
+          response.start(403) do |head,out|
+            out << "You are not allowed to go inside here !!!"
+          end
+          return
+        end
+
+        # Block if no listing is allowed and this is a directory...
+        if ru.is_dir? and not app.listing_allowed
+          response.start(403) do |head,out|
+            out << "Listing is not unabled for this application!"
+          end
+          return
+        end
+        
+        # Block if listing is allowed but directory is not allowed...
+        if ru.is_dir? and app.listing_allowed and not app.dirs_allowed_for_listing.empty?
+
+          allowed = false
+          
+          app.dirs_allowed_for_listing.each do |dir|
+            dir = '/' + dir if dir !~ /^\//
+            if ru.url_without_context_dir =~ /^#{dir}\/?$/
+              allowed = true
+              break
+            end
+          end
+          
+          if not allowed
+            response.start(403) do |head,out|
+              out << "You cannot list this directory! (Forbidden)"
+            end
+            return
+          end
+        end
+          
+        if url =~ /\.#{app.extension}\??$/ or url =~ /\.#{app.extension}\?.+$/
+          # We need to process this inside the Mentawai controller... (action request)
+          super
+        elsif (url =~ /(\.\w+)\??$/ or url =~ /(\.\w+)\?.+$/) and Mentawai::Core::Forward.is_registered?($1)
+          # We need to process this inside the Mentawai controller... (ERB page request)
+          super
+        else
+          # Change Mongrel request to reflect the context path dir...
+          request.params["PATH_INFO"] = ru.url_with_context_dir
+
+          # Let Mongrel serve this request...
+          @dir_handler.process(request, response)
+        end
+      end
+      
+    end
+    
+    class RequestURL
+      
+      def initialize(context_path, context_path_dir, url, default_page)
+
+        # Construct file path for the URL...
+        if context_path == '/'
+          @url_file_path = '.' + context_path_dir + url
+          @url_with_context_dir = context_path_dir + url
+          @url_without_context_dir = url
+        else
+          @url_file_path = '.' + url
+          @url_with_context_dir = url
+          @url_without_context_dir = url.sub(/#{context_path_dir}/, "")
+          @url_without_context_dir = '/' if @url_without_context_dir == ""
+        end
+        
+        @is_dir = File.directory?(@url_file_path)
+        
+        # Check if we need to append the default_page
+        if @is_dir
+          url_file_path_with_default_page = append_filename(@url_file_path, default_page)
+          if File.exists?(url_file_path_with_default_page)
+            @is_dir = false
+            @url_without_context_dir = append_filename(@url_without_context_dir, default_page)
+            @url_with_context_dir = append_filename(@url_with_context_dir, default_page)
+            @url_file_path = url_file_path_with_default_page
+          end
+        end
+        
+        # Check if this is a forbidden URL
+        if @url_with_context_dir =~ /^#{context_path_dir}\/WEB-INF/
+          @forbidden = true
+        else
+          @forbidden = false
+        end
+      end
+      
+      attr_reader :url_without_context_dir, :url_with_context_dir, :url_file_path
+      
+      def is_dir?
+        @is_dir
+      end
+      
+      def forbidden?
+        @forbidden
+      end
+      
+      def to_s
+        "RequestURL: without=#{url_without_context_dir} with=#{url_with_context_dir} path=#{url_file_path} forbidden=#{forbidden?} is_dir=#{is_dir?}"
+      end
+      
+      private
+      
+      def append_filename(path, filename)
+        p = path
+        p += '/' if p !~ /\/$/
+        p += filename
+      end
+      
+    end
+
+  end
+end

data/lib/mentawai/i18n/loc_manager.rb

@@ -0,0 +1,61 @@
+require 'singleton'
+
+module Mentawai
+  module I18N
+    
+    class LocaleManager
+      include Singleton
+      
+      def initialize
+        @locales = Array.new
+      end
+      
+      def add(loc)
+        @locales.add(loc)
+      end
+      
+      def locales
+        @locales
+      end
+      
+      def default
+        if @locales.empty?
+          'en_US'
+        else
+          @locales[0]
+        end
+      end
+      
+      def get(locale, return_default = true)
+        
+        if locale.nil?
+          return return_default ? default : nil
+        end
+        
+        # If array, try to match any of them
+        if locale.is_a?(Array)
+          locale.each do |loc|
+            l = get(loc, false) # recursive no default here...
+            return l if l
+          end
+          return return_default ? default : nil 
+        end
+        
+        # First match the whole thing
+        @locales.each do |loc|
+          return loc if locale == loc 
+        end
+        # Now match only the language
+        l = locale.split(/_/)[0]
+        @locales.each do |loc|
+          l2 = loc.split(/_/)[0]
+          return loc if l2 == l
+        end
+        # Return default or the given locale
+        return_default ? default : nil
+      end
+      
+    end
+    
+  end
+end

data/lib/mentawai/loader.rb

@@ -12,7 +12,13 @@ module Mentawai
       @files = { }
       
       Dir.glob(@file_mask).each do |f|
+        
+        # Skip some files here...
         next if f =~ /loader\.rb$/
+        next if f =~ /menta_handler\.rb$/
+        next if f =~ /server\.rb$/
+        next if f =~ /application\.rb$/
+        
         @files[File.new(f)] = 0
       end
       

data/lib/mentawai/page/methods/content_type.rb

@@ -0,0 +1,19 @@
+require 'mentawai/page/page_method'
+
+module Mentawai
+  module Page
+    module Method
+    
+      class ContentType < Mentawai::Page::PageMethod
+      
+        def set_content_type
+          raise "Value attribute is mandatory!" if not arg?(:value)
+          if consequence and consequence.respond_to?(:content_type=)
+            consequence.content_type = arg[:value]                      
+          end
+        end
+        
+      end
+    end
+  end
+end