mentawai 0.5.0

data/lib/mentawai/page/page_method.rb

@@ -0,0 +1,137 @@
+module Mentawai
+  module Page
+    
+    class PageMethod
+      
+      def initialize(action, parameters)
+        @action = action
+        @params = turn_to_hash(parameters)
+      end
+      
+      def params
+        @params
+      end
+      
+      alias args params
+      alias param params
+      alias arg params
+      
+      def param?(p)
+        @params.key?(p)
+      end
+      
+      alias key? param?
+      alias arg? param?
+      alias has_param? param?
+      alias has_key? param?
+      alias has_arg? param?
+      
+      def action
+        @action
+      end
+      
+      def input
+        @action.input
+      end
+      
+      def output
+        @action.output
+      end
+      
+      def session
+        @action.session
+      end
+      
+      def cookies
+        @action.cookies
+      end
+      
+      def application
+        @action.application
+      end
+      
+      def locale
+        @action.locale
+      end
+      
+      def page
+        @action.page
+      end
+      
+      protected
+      
+      def find_value(name)
+        return nil if @action.nil?
+        
+        # Ex: user.address.street
+        parts = name.split(/\./)
+        
+        if parts.length > 1 then
+          # The first will be found normally from page, output, etc.
+          first = find_value(parts[0]) # safe recursive call
+          return nil if first.nil?
+          
+          # Now find properties of the object found
+          curr_obj = first
+          for index in (1...parts.length) do
+            curr_obj = get_value_by_reflection(curr_obj, parts[index])
+            return nil if curr_obj.nil?
+          end
+          return curr_obj
+        end
+        
+        # Rule is simple: page, output, session and application
+        
+        return page[name] if page.key?(name)
+        return output[name] if output.key?(name)
+        return session[name] if session.key?(name)
+        return application[name] if application.key?(name)
+        nil
+      end
+      
+      def find_form_value(name)
+        return nil if @action.nil?
+        return output[name] if output.key?(name)
+        return input[name]  if input.key?(name)
+        nil
+      end
+      
+      private
+      
+      def get_value_by_reflection(obj, name)
+        # Try getter method
+        if obj.class.public_method_defined?(name) then
+          m = obj.method(name)
+          return m.call if m.arity <= 0
+        end
+        
+        # Try instance variable
+        if obj.instance_variable_defined?("@#{name}") then
+          return obj.instance_variable_get("@#{name}")
+        end
+        
+        # Try [] method (for hashes and similar objects)
+        if obj.class.public_method_defined?('[]') then
+          m = obj.method('[]')
+          return m.call(name) if m.arity == 1
+        end
+        
+        # Not found
+        nil
+      end
+      
+      def turn_to_hash(parameters)
+        if parameters.nil? then
+          Hash.new
+        elsif parameters.is_a?(Hash) then
+          parameters
+        else
+          { :value => parameters.to_s }
+        end
+      end
+      
+    end
+    
+    
+  end
+end

data/lib/mentawai/server.rb

@@ -0,0 +1,106 @@
+require 'rack' 
+require 'mentawai/loader'
+require 'mentawai/session/menta_session'
+
+module Mentawai
+
+  class Server
+  
+    attr_accessor :host, :port
+  
+    def initialize(path = nil)
+      
+      @host = "127.0.0.1"
+      @port = 8080
+      
+      @apps = Hash.new
+      
+      if not path
+        @loader = nil
+      else
+        @loader = Mentawai::Loader.new(path + '/Mentawai')
+        @loader.reloadFiles
+      end
+
+    end
+    
+    def application(contextPath, appManagerFilename, appManagerClass)
+      raise "Context already exists: " + contextPath if @apps.has_key?(contextPath)
+      @apps[contextPath] = Application.new(contextPath, appManagerFilename, appManagerClass)
+    end
+    
+    def call(env)
+    
+      # force reload of any mentawai file if modified...
+      filesLoaded = 0; filesLoaded = @loader.reloadFiles if @loader
+    
+      req = Rack::Request.new(env)
+      res = Rack::Response.new(env)
+    
+      # Extract context path from URL...
+      if req.fullpath =~ /(\/[^\/]*)/ then
+        contextPath = $1
+      else
+        raise "Cannot get context path: " + env.fullpath
+      end
+      
+      # Decide about context path...
+      if @apps.has_key?(contextPath) then
+        # context path was found! (NOOP)
+      elsif @apps.has_key?('/') then
+        contextPath = '/'
+      else
+        raise "Cannot find context: " + contextPath
+      end
+      
+      env['menta.contextPath'] = contextPath
+      
+      app = @apps[contextPath]
+      app.reloadAppManager(filesLoaded > 0)
+      
+      controller = Mentawai::Core::Controller.new(app.contextPath, app.appContext, app.appManager)
+      controller.service(env, req, res)
+    end
+    
+    def start
+      
+      session_config = { :cookie_expire_after => 0, :session_expire_after => 10 }
+      session_server = Mentawai::Session::MentaSession.new(self, session_config)
+      config = {:Host => @host, :Port => @port}
+      Rack::Handler::Mongrel.run(session_server, config)      
+    end
+    
+    class Application
+    
+      attr_reader :contextPath, :appContext, :appManagerFilename, :appManagerClass, :appManagerFile, :appManager
+    
+      def initialize(contextPath, appManagerFilename, appManagerClass)
+        raise "Application manager does not exist: " + appManagerFilename if not File.exists?(appManagerFilename)
+        @appContext = Hash.new
+        @contextPath = contextPath
+        @appManagerFilename = appManagerFilename
+        @appManagerClass = appManagerClass
+        @appManagerFile = File.new(appManagerFilename)
+        @appManagerFileLastModified = 0
+        reloadAppManager
+      end
+      
+      def reloadAppManager(force = false)
+        if force || @appManagerFile.mtime != @appManagerFileLastModified then
+          if @appManagerFileLastModified == 0 then
+            puts "Loading app manager: " + @appManagerFilename
+          else
+            puts "Reloading app manager: " + @appManagerFilename
+          end
+          load @appManagerFilename
+          @appManager = eval(appManagerClass + ".new")
+          @appManager.init(@appContext)
+          @appManagerFileLastModified = @appManagerFile.mtime
+        end
+      end
+      
+    end
+    
+  end
+
+end

data/lib/mentawai/session/menta_session.rb

@@ -0,0 +1,84 @@
+require 'rack'
+require 'mentawai/session/rack_session'
+
+module Mentawai
+  module Session
+    
+    class MentaSession < RackSession
+      
+      def initialize(app, options = {}) # in minutes
+        
+        # Rename expire_after to cooki_expire_after for clarity...
+        if options.key?(:cookie_expire_after) then
+          options[:expire_after] = options[:cookie_expire_after]
+        end
+        
+        timeout = 10 # default
+        timeout = options[:session_expire_after] if options.key?(:session_expire_after)
+
+        @timeout = (timeout * 60).to_i # now in seconds (allow float timeout)
+        @lastcheck = Time.now
+        
+        super
+      end
+      
+      # Convenient method to get session_id from cookie
+      def get_session_id(env)
+        env.fetch('HTTP_COOKIE','')[/#{@key}=([^,;]+)/,1] # copied from Rack code
+      end
+      
+      # Override loadSession to purge expired sessions...
+      
+      def load_session(env)
+        
+        now = Time.now
+        
+        @lock.synchronize {
+        
+          # Check if session was invalidated...
+          session_id = get_session_id(env)
+          if session_id && pool.key?(session_id) then
+            
+            s = pool[session_id]
+            sdat = s.instance_variable_get '@dat'
+            
+            raise "Something is wrong!" unless sdat[0] == session_id # sanity...
+            
+            lastaccess = sdat[1]
+            
+            if lastaccess == 0 || now - lastaccess > @timeout then
+              pool.delete(session_id)
+              
+              s.each do |k,v|
+                v.removed_from_session(k) if v.respond_to?(:removed_from_session)
+              end
+              
+            end
+            
+          end
+          
+          if now - @lastcheck >= @timeout then
+            # now purge all expired sessions...
+            pool.each do |id,session|
+              sdat = session.instance_variable_get '@dat'
+              lastaccess = sdat[1]
+              if lastaccess == 0 || now - lastaccess > @timeout then
+                pool.delete(id) 
+                session.each do |k,v|
+                  v.removed_from_session(k) if v.respond_to?(:removed_from_session)
+                end
+              end
+            end
+            @lastcheck = now
+          end
+        
+        }
+        
+        super # do what you have to do...
+        
+      end
+      
+    end
+    
+  end
+end

data/lib/mentawai/session/rack_session.rb

@@ -0,0 +1,91 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+# Modified by Sergio Oliveira to synchronize the pool of sessions...
+
+require 'thread'
+
+module Mentawai
+  module Session
+    # Rack::Session::Pool provides simple cookie based session management.
+    # Session data is stored in a hash held by @pool. The corresponding
+    # session key sent to the client.
+    # The pool is unmonitored and unregulated, which means that over
+    # prolonged use the session pool will be very large.
+    #
+    # Example:
+    #
+    #     use Rack::Session::Pool, :key => 'rack.session',
+    #                              :domain => 'foo.com',
+    #                              :path => '/',
+    #                              :expire_after => 2592000
+    #
+    #     All parameters are optional.
+
+    class RackSession
+      
+      attr_reader :pool, :key
+
+      def initialize(app, options={})
+        @app = app
+        @key = options[:key] || "rack.session"
+        @default_options = {:domain => nil,
+          :path => "/",
+          :expire_after => nil}.merge(options)
+        @pool = Hash.new
+        @default_context = context app, &nil
+        @lock = Mutex.new
+      end
+
+
+      def call(env)
+        @default_context.call(env)
+      end
+
+      def context(app, &block)
+        Rack::Utils::Context.new self, app do |env|
+          load_session env
+          block[env] if block
+          response = app.call(env)
+          commit_session env, response
+          response
+        end
+      end
+
+      private
+
+      def load_session(env)
+        
+        sess_id = env.fetch('HTTP_COOKIE','')[/#{@key}=([^,;]+)/,1]
+        
+        @lock.synchronize {
+          begin
+            sess_id = Array.new(8){rand(16).to_s(16)}*''
+          end while @pool.key? sess_id if sess_id.nil? or !@pool.key? sess_id
+  
+          session = @pool.fetch sess_id, {}
+          @pool.store sess_id, env['rack.session'] = session
+          session.instance_variable_set '@dat', [sess_id, Time.now]
+        }
+
+        env["rack.session.options"] = @default_options.dup
+      end
+
+      def commit_session(env, response)
+        session = env['rack.session']
+        options = env['rack.session.options']
+        sdat    = session.instance_variable_get '@dat'
+
+        cookie = Rack::Utils.escape(@key)+'='+ Rack::Utils.escape(sdat[0])
+        cookie<< "; domain=#{options[:domain]}" if options[:domain]
+        cookie<< "; path=#{options[:path]}" if options[:path]
+        cookie<< "; expires=#{sdat[1]+options[:expires_after]}" if options[:expires_after]
+
+        case a = (h = response[1])['Set-Cookie']
+        when Array then  a << cookie
+        when String then h['Set-Cookie'] = [a, cookie]
+        when nil then    h['Set-Cookie'] = cookie
+        end
+      end
+
+    end
+  end
+end

data/lib/mentawai/util/string.rb

@@ -0,0 +1,34 @@
+
+class String
+
+  alias each_byte_orig each_byte
+  alias lindex index
+
+  def each_byte
+    index = 0
+    each_byte_orig do |b|
+      yield b, index
+      index += 1
+    end
+  end
+  
+  def each_char
+    index = 0
+    each_byte_orig do |b|
+      yield b.chr, index
+      index += 1
+    end
+  end
+  
+  def String.testMe
+    "aaa".each_byte { |b,n| print "Byte: #{b} (#{n})\n" }
+    "aaa".each_char { |c,n| print "Char: #{c} (#{n})\n" }
+    print "Index: ","aaabbbccc".lindex('ab'),"\n"
+  end
+  
+end
+
+String.testMe if ARGV[0] == "testMe"
+
+
+  

data/lib/mentawai/version.rb

@@ -0,0 +1,9 @@
+module Mentawai #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 5
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/mentawai.rb

@@ -0,0 +1,16 @@
+# Require all mentawai files here...
+
+root = File.expand_path(File.dirname(__FILE__))
+
+# Load two lonely files in mentawai/
+
+require root + '/mentawai/loader'
+require root + '/mentawai/server'
+
+# Now loop and load everything inside '/mentawai/**'
+
+path = root + '/mentawai/**/*.rb'
+
+Dir.glob(path).each do |file|
+  require file
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/mentawai/version.rb'
+
+version  = Mentawai::VERSION::STRING
+download = 'http://rubyforge.org/projects/mentawai'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)