mentawai 0.5.0

data/lib/mentawai/core/controller.rb

@@ -0,0 +1,233 @@
+require 'monitor'
+
+module Mentawai
+  module Core
+
+    class Controller
+      
+      @@forward_cache = Hash.new
+      @@forward_cache.extend(MonitorMixin)
+      
+      def initialize(contextPath, appContext, appManager)
+        @contextPath = contextPath
+        @appContext = appContext
+        @appManager = appManager
+      end
+      
+      attr_reader :appManager, :action, :contextPath
+      
+      def output
+        @action.output
+      end
+      
+      def application
+        @action.application
+      end
+      
+      def input
+        @action.input
+      end
+      
+      def session
+        @action.session
+      end
+      
+      def locale
+        @action.locale
+      end
+      
+      def cookies
+        @action.cookies
+      end
+      
+      def page
+        @action.page
+      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
+        end
+        
+        fix_url(url)
+        
+        url.gsub!(/\.\w{1,4}$/, "") # remote any extension (max 4 chars)
+    
+        actionName = nil    
+        innerAction = nil
+        
+        if (index = url.rindex('.')) != nil then
+          actionName = url[0, index]
+          innerAction = url[index + 1, url.length]
+        else
+          actionName = url
+        end
+        
+        @appManager.reloadActions
+        
+        ac = @appManager.getActionConfig(actionName, innerAction)
+
+        if ac then
+          @action = eval("#{ac.className}.new")
+        else
+          # If you cannot find action config then use conventions...
+          @action = eval("#{actionName}.new")
+        end
+        
+        prepare(@action, req, res)
+        
+        chain = InvocationChain.new(@action, actionName, innerAction)
+        
+        @appManager.filters { |f| chain.addFilter(f) }
+        
+        ac.filters { |f| chain.addFilter(f) } if ac
+        
+        result = chain.invoke
+        
+        conseq = nil
+        
+        conseq = ac.getConsequence(result) if ac
+        
+        conseq = @appManager.getConsequence(result) if not conseq
+        
+        if not conseq then
+          
+          # Use conventions to find a view
+          dest = actionName + "/" + (innerAction ? innerAction : 'index') + '.erb'
+          
+          # Cache forward consequence...
+          @@forward_cache.synchronize {
+            conseq = @@forward_cache[dest]
+            if not conseq then
+              # Check if file exists
+              if File.exists?("./views/" + dest) then
+                @@forward_cache[dest] = conseq = Forward.new(dest)
+              end
+            end
+          }
+        end
+
+        raise "Cannot find consequence! action=#{actionName} inner=#{innerAction ? innerAction : 'nil'}" if not conseq
+        
+        conseq.exec(self, req, res, @action)
+        
+      end
+      
+      def service_direct(env, req, res)
+        
+        # Accessing a page file directly
+        
+        url = req.fullpath.dup
+        
+        fix_url(url)
+        
+        @action = Mentawai::Core::Action.new
+        
+        prepare(@action, req, res)
+        
+        forward = nil
+        
+        # Cache forward consequence...
+        @@forward_cache.synchronize {
+          forward = @@forward_cache[url]
+          @@forward_cache[url] = forward = Forward.new(url) if not forward
+        }
+        
+        forward.exec(self, req, res, @action)
+        
+      end
+        
+      protected
+      
+      def fix_url(url)
+        url.gsub!(/^#{@contextPath}/, "") # remove context path
+        url.gsub!(/\?.*$/, "") # remove query string (if present)
+        url.gsub!(/^\//, "") # remove a '/' from begining
+        url.gsub!(/\/$/, "") # remove a '/' from ending
+      end
+      
+      def prepare(action, request, response)
+        i = Input.new(request)
+        o = Output.new(response)
+        s = Session.new(request, response)
+        c = Cookies.new(request, response)
+        
+        if action.is_a?(Action) then
+          action.input = i
+          action.output = o
+          action.session = s
+          action.cookies = c
+          action.application = @appContext
+          action.page = Hash.new
+        else
+          raise "Not an action: " + action.to_s
+        end
+      end
+    end
+    
+    private
+    
+    def exec_page_method(className, methodName, args)
+      if args.length <= 0 then
+        m = eval(className + ".new(self, nil)")  
+      else
+        m = eval(className + ".new(self, args[0])")
+      end
+      m.send(methodName)
+    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;
+      #
+      # Ex:
+      #       class MyAction < Mentawai::Core::Action
+      #         def execute
+      #           a = {}
+      #           a.blow
+      #         end
+      #       end
+      #
+      #       The action above will trigger method_missing from
+      #       the controller! Now you tell me why!!!
+      if not self.is_a?(Controller)
+        # This method missing is from the Controller only!
+        # I don't want actions triggering this guys!
+        # You tell me why this is happening since I have already
+        # tried everything to understand this...
+        super
+      end
+      
+      # First look custom page methods
+      if args.length <= 1 && @appManager.customPageMethods.key?(id) then
+        
+        className = @appManager.customPageMethods[id][0]
+        methodName = @appManager.customPageMethods[id][1]
+        exec_page_method(className, methodName, args)
+        
+        # Then look menta page methods
+      elsif args.length <= 1 && @appManager.pageMethods.key?(id) then
+      
+        className = @appManager.pageMethods[id][0]
+        methodName = @appManager.pageMethods[id][1]
+        exec_page_method(className, methodName, args)
+        
+      else
+        super
+      end
+    end
+    
+  end
+end
+
+    
+        

data/lib/mentawai/core/cookies.rb

@@ -0,0 +1,57 @@
+module Mentawai
+  module Core
+
+    class Cookies
+      
+      attr_reader :request, :response
+      
+      def initialize(request, response)
+        @req = request
+        @res = response
+        @cookies = request.cookies
+      end
+      
+      def put(key, value)
+        @res.set_cookie(key, value)
+      end
+      
+      def get(key)
+        @cookies[key]
+      end
+      
+      def remove(key)
+        @res.delete_cookie(key)
+      end
+      
+      def hasKey?(key)
+        @cookies.has_key?(key)
+      end
+      
+      alias has_key? hasKey?
+      alias key? hasKey?
+      
+      def keys
+        @cookies.each do |k,v|
+          yield k
+        end
+      end
+      
+      def values
+        @cookies.each do |k,v|
+          yield k,v
+        end
+      end
+      
+      alias each values
+      alias [] get
+      alias []= put
+      alias delete remove
+      
+    end
+      
+  end
+end
+
+      
+      
+      

data/lib/mentawai/core/forward.rb

@@ -0,0 +1,57 @@
+require 'erubis'
+require 'thread'
+
+module Mentawai
+  module Core
+  
+    class Forward
+      
+      DEFAULT_TYPE = 'text/html'
+      
+      @@types = Hash.new
+      @@types['erb'] = 'text/html'
+      @@types['txt'] = 'text/plain'
+      @@types['xml'] = 'text/xml'
+      
+      def self.types
+        @@types
+      end
+    
+      def initialize(page)
+        @page = page
+        if page =~ /\.(\w+)$/ then
+          @contentType = @@types[$1] || DEFAULT_TYPE
+        else
+          @contentType = DEFAULT_TYPE
+        end
+        @filename = './views/' + page
+        raise "Cannot find page: " + page if not File.exists?(@filename)
+        @file = File.new(@filename)
+        @lastmodified = @file.mtime
+        input = File.read(@filename)
+        @eruby = Erubis::Eruby.new(input)
+        @lock = Mutex.new
+      end
+      
+      def exec(controller, req, res, action)
+        @lock.synchronize {
+          if @lastmodified != @file.mtime then
+            input = File.read(@filename)
+            @eruby = Erubis::Eruby.new(input)
+            @lastmodified = @file.mtime
+            puts "Reloading #{@page}"
+          end
+        }
+        data = @eruby.result(controller.send(:binding))
+        
+        res['Content-Type'] = @contentType
+        res.status = 200 # OK
+        res.body = data
+        
+        res.finish
+        
+      end
+    end
+    
+  end
+end

data/lib/mentawai/core/input.rb

@@ -0,0 +1,99 @@
+module Mentawai
+  module Core
+
+    class Input
+    
+      attr_reader :request
+    
+      def initialize(req)
+        @request = req
+        
+        # Copy params...
+        @params = Hash.new
+        req.params.each { |k,v| @params[k] = v }
+        
+        # Copy headers...
+        @headers = Hash.new
+        req.env.each do |k,v|
+          @headers[k] = v if k =~ /^[A-Z]/ # Begin with capital
+        end
+      end
+        
+      def get(key)
+        @params[key]
+      end
+    
+      def put(key, value)
+        @params[key] = value
+      end
+        
+      def remove(key)
+        @params.delete(key)
+      end
+        
+      def getHeader(key)
+        @headers[key]
+      end
+        
+      def headers
+        @headers.each do |k,v|
+          yield k
+        end
+      end
+    
+      def keys
+        @params.each do |k,v|
+          yield k
+        end
+      end
+    
+      def values
+        @params.each do |k,v|
+          yield k,v
+        end
+      end
+    
+      def hasKey?(key)
+        @params.has_key?(key)
+      end
+    
+      alias has_key? hasKey? 
+      alias key? hasKey?
+      
+      def hasProperty?(prop)
+        @request.class.public_instance_methods.each do |m|
+          return 1 if m == prop
+        end
+        nil
+      end
+      
+      alias has_property? hasProperty?
+      alias has_prop? hasProperty?
+      alias hasProp? hasProperty?
+      
+      def getProperty(prop)
+        @request.class.public_instance_methods.each do |m|
+          if m == prop then
+            return @request.send(prop)
+          end
+        end
+        nil
+      end
+      
+      alias getProp getProperty
+      alias get_prop getProperty
+      alias get_property getProperty
+      alias property getProperty
+      alias prop getProperty
+      alias each values
+      
+      alias [] get
+      alias []= put
+          
+    end
+    
+  end
+end
+
+    
+            

data/lib/mentawai/core/invocation_chain.rb

@@ -0,0 +1,58 @@
+module Mentawai
+    module Core
+      
+      class InvocationChain
+        
+        def initialize(action, actionName, innerAction)
+          @action = action
+          @actionName = actionName
+          @filters = Array.new
+          @innerAction = innerAction
+        end
+        
+        def action
+          @action
+        end
+        
+        def actionName
+          @actionName
+        end
+        
+        def innerAction
+          @innerAction
+        end
+        
+        def addFilter(filter)
+          @filters.push(filter)
+        end
+        
+        def addFilters(filters)
+          filters.each do |f|
+            @filters.push(f)
+          end
+        end
+        
+        def filters
+          @filters.each do |f|
+            yield f
+          end
+        end
+
+        def invoke
+          
+          if !@filters.empty? then
+            f = @filters.shift
+            return f.filter(self)
+          end
+
+          if @innerAction != nil then
+            @action.send(@innerAction)
+          else
+            @action.execute
+          end
+        end
+        
+      end
+      
+    end
+end

data/lib/mentawai/core/output.rb

@@ -0,0 +1,51 @@
+module Mentawai
+  module Core
+
+    class Output
+    
+      attr_reader :response
+    
+      def initialize(res)
+        @response = res
+        @values = Hash.new
+      end
+      
+      def get(key)
+        @values[key]
+      end
+      
+      def put(key, value)
+        @values[key] = value
+      end
+      
+      def hasKey?(key)
+        @values.has_key?(key)
+      end
+      
+      alias has_key? hasKey?
+      alias key? hasKey?
+      
+      def remove(key)
+        @values.delete(key)
+      end
+      
+      def keys
+        @values.each do |k,v|
+          yield k
+        end
+      end
+      
+      def values
+        @values.each do |k,v|
+          yield k,v
+        end
+      end
+      
+      alias [] get
+      alias []= put
+      alias each values
+      
+    end
+    
+  end
+end

data/lib/mentawai/core/session.rb

@@ -0,0 +1,75 @@
+module Mentawai
+  module Core
+
+    class Session
+    
+        attr_reader :request, :response
+    
+      def initialize(req, res)
+        @request = req
+        @response = res
+        @session = req.env['rack.session']
+        @sdat = @session.instance_variable_get '@dat'
+      end
+      
+      def sid
+        @sdat[0]
+      end
+      
+      def get(key)
+        @session[key]
+      end
+      
+      def put(key, value)
+        
+        # Are we replacing an object?
+        if @session.key?(key) then
+          removed = @session[key]
+          if not value.equal?(removed) then
+            removed.removed_from_session(key) if removed.respond_to?(:removed_from_session)            
+          end
+        end
+        
+        @session[key] = value
+        value.added_to_session(key) if value.respond_to?(:added_to_session)
+      end
+      
+      def remove(key)
+        removed = @session.delete(key)
+        removed.removed_from_session(key) if removed.respond_to?(:removed_from_session)
+      end
+      
+      def hasKey?(key)
+        @session.has_key?(key)
+      end
+    
+      alias has_key? hasKey?
+      alias key? hasKey?
+      
+      def keys
+        @session.each do |k,v|
+          yield k
+        end
+      end
+      
+      def values
+        @session.each do |k,v|
+          yield k,v
+        end
+      end
+      
+      def reset
+        @sdat[1] = 0 # expire it!
+      end
+      
+      alias [] get
+      alias []= put
+      alias delete remove
+      alias each values
+      
+    end
+    
+  end
+end
+
+          

data/lib/mentawai/loader.rb

@@ -0,0 +1,54 @@
+module Mentawai
+  class Loader
+  
+    def initialize(mentaPath = nil)
+      if mentaPath then
+        @file_mask = mentaPath + '/**/*.rb'
+      else
+        @file_mask = './Mentawai/**/*.rb'
+      end
+      
+      puts "File mask: #{@file_mask}"
+      @files = { }
+      
+      Dir.glob(@file_mask).each do |f|
+        next if f =~ /loader\.rb$/
+        @files[File.new(f)] = 0
+      end
+      
+      raise "Cannot load Mentawai files: #{@file_mask}" if @files.size == 0
+      
+    end
+    
+    def showFiles
+      @files.each do |f,t|
+        puts "#{f.path}: #{t}"
+      end
+    end
+    
+    def files_count
+      @files.size
+    end
+    
+    alias size files_count
+    alias length files_count
+    
+    def reloadFiles
+      count = 0
+      @files.each do |f,t|
+        if t == 0 then
+          puts "Loading #{f.path}" # first time
+          load f.path
+          count += 1
+        elsif t != f.mtime
+          puts "Reloading #{f.path}" # was modified
+          load f.path
+          count += 1
+        end
+        @files[f] = f.mtime # update modified time
+      end
+      count
+    end
+    
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'mentawai/page/page_method'
+
+module Mentawai
+  module Page
+    module Method
+    
+      class Out < Mentawai::Page::PageMethod
+      
+        def print
+          raise "Value attribute is mandatory!" if not arg?(:value)
+          find_value(arg[:value])
+        end
+        
+      end
+    end
+  end
+end