cuca 0.01

data/lib/cuca/app.rb

@@ -0,0 +1,317 @@
+require 'logger'
+ 
+
+module Cuca
+
+# Sandbox is used internally run the action script defined by the controller
+# In future this can be extended to implement some security features etc..
+class Sandbox
+ def self.run(controller_class_name, mod, assigns, request_method, subcall)
+   self.class.send(:include, mod)
+   controller_class = mod::const_get(controller_class_name)
+   controller = controller_class.send(:new, :assigns=>assigns)
+   controller.run_before_filters
+
+
+   controller.send('_do'.intern, 'run', subcall)
+   case $cgi.request_method
+       when 'POST' 
+            controller.send('_do'.intern, 'post', subcall)
+       when 'GET' 
+            controller.send('_do'.intern, 'get', subcall)
+   end
+   return controller.send(:to_s)
+ end
+end
+
+# == Cuca Application
+# 
+# A Cuca::App object will be created directly by the dispatcher - which again is the 
+# direct cgi or fastcgi script that get run by the webserver.
+# Normally you just create a Cuca::App object and run the cgicall function with optional with 
+# a cgi object as paramenter. 
+# Before doing that you must set $cuca_path to the root of your appication structure.
+
+class App
+
+ # == Configure the application
+ # App::Config is normally called from conf/environment.rb . The attributes below the framework
+ # will make use of, but you can always define own ones.
+ #
+ # == Example
+ #
+ #  Cuca::App.configure do |conf|
+ #      conf.include_directories = %{_widgets _special_widgets}
+ #      conf.database            = 'mydb'		# application specific
+ #  end
+ # === Attributes:
+ #
+ # * include_directories
+ #  An array of directories that will be automatically included if you call an action.
+ #  If one of the directories is found in the path where the action file is located it will require
+ #  all files found. (default: %w{_controllers _widgets _layouts} )
+ # * log_level - default 3
+ # * magic_prefix - default: '__default_' (see Cuca::Controller)
+ class Config < Hash
+   def method_missing(m, *params)
+       met = m.id2name
+       raise NoMethodError if met[met.size-1].chr != '='
+       self[met[0..met.size-2]] = params[0]
+   end
+   
+   # some default stuff
+   def initialize
+     self['include_directories'] = %w{_controllers _widgets _layouts}
+     self['log_level']  = 3
+     self['magic_prefix'] = '__default_'
+     self['directory_seperator'] = '/'		# future?
+     self['session_key'] = 'cuca_session'
+     self['session_prefix'] = 'cuca.'
+     self['session_valid'] = 3600*24
+     self['view_directoru'] = 'app/_view'	# where to find views for the view/erb generator
+     
+   end
+   
+ end
+
+ attr_reader :conf, :cgi, :logger, :urlmap
+
+ @@app_config = Config.new
+
+ ## Application configuration
+ public
+ def self.configure
+   yield @@app_config
+ end
+
+ def self.config
+   @@app_config
+ end
+
+ 
+ # cgi implementation test
+ private
+ def cgidump(cgi)
+   s = ""
+   s << "-----ENV------<br>"
+   cgi.env_table.each_pair { |k,v| s << "#{k} => #{v}<br>" }
+   s << "--------------<br>"
+   s << "Server Software: #{cgi.server_software}<br>"
+   s << "PATH INFO: #{cgi.path_info}<br>"      
+ end
+
+ # Creates the @conf global variable - internal config
+ #
+ # APP_PATH = Path the the /app folder
+ # CGI = CGI object
+ # DEF_EXT = Default script extensions (.rb)
+ # DEF_ACTION = (like 'index')
+ # SCRIPT = Full path to the ruby script dealing with ACTION
+ # ACTION = Action called (=links to SCRIPT, eg 'show' or 'index')
+ # PATH_INFO = raw path info as from cgi 
+ # PATH_TREE = array of path, without action
+ private
+ def mk_config
+   @conf = {}
+ 
+ # To have a look at ENV and cgi uncomment this
+#   @cgi.out { cgidump(@cgi) }
+#   raise "Debug stop"
+ 
+
+   # APP_PATH = Path the the /app folder
+#   @conf['APP_PATH'] = File.expand_path(File.dirname(__FILE__)+"/../app")
+   @conf['APP_PATH'] = $cuca_path + "/app"
+   
+   # PUBLIC_PATH = Path to the /public folder
+#   @conf['PUBLIC_PATH'] = File.expand_path(File.dirname(__FILE__)+"/../public")
+    @conf['PUBLIC_PATH'] = $cuca_path + "/public"
+   
+   # LOG_PATH = Path to logging directory
+#   @conf['LOG_PATH'] = File.expand_path(File.dirname(__FILE__)+"/../log")
+   @conf['LOG_PATH'] = $cuca_path + "/log"
+  
+   # CGI = CGI object
+   @conf['CGI'] = @cgi
+   
+   # DEF_EXT = Default script extensions
+   @conf['DEF_EXT'] = ".rb"
+   
+   @conf['DEF_ACTION'] = 'index'
+
+   # Cookie name
+   @conf['COOKIE_NAME'] = 'cucahap'
+      
+   # ACTION = Action called (=links to SCRIPT), eg 'index'
+   @conf['ACTION'] =  @cgi.path_info.reverse[0].chr == '/' ? @conf['DEF_ACTION'] : @cgi.path_info.split('/').last.downcase
+    
+   # PATH_INFO = raw path info as from cgi
+   @conf['PATH_INFO'] = @cgi.path_info
+   
+   # PATH_TREE = path info as array - without action
+#   @conf['PATH_TREE'] = [''].concat(@conf['PATH_INFO'].split('/').collect { |e| (e==@conf['ACTION'] || e == '') ? nil : e }.compact)
+
+   
+   require 'cuca/urlmap'
+   
+   begin
+     mapping = URLMap.new(File.expand_path(@conf['APP_PATH']), @conf['PATH_INFO'])
+     @conf['SUBCALL'] = mapping.subcall
+     @conf['SCRIPT']  = mapping.script
+     @conf['ASSIGNS'] = mapping.assigns
+     @conf['ACTION']  = mapping.action
+     @urlmap = mapping
+   rescue RoutingError => r
+     @conf['SCRIPT'] = "#{@conf['PUBLIC_PATH']}/#{@conf['PATH_INFO']}"
+     return 
+#     raise "RoutingError: #{r}"
+   end
+   
+   # get the PATH_TREE for file inclusion!
+
+   c_ap = File.expand_path(@conf['APP_PATH'])
+   pt = @conf['SCRIPT'][c_ap.size..-1]
+   ac_script = @conf['SCRIPT'].split('/').last
+   @conf['PATH_TREE'] = [''].concat(pt.split('/').collect { |e| (e==ac_script || e == '') ? nil : e }.compact)
+ end
+ 
+ # will do a 'require' on all .rb files in path
+ private
+ def include_files(path)
+   return unless File.exist?(path)
+   pwd = Dir.pwd
+   Dir.chdir(path)
+   Dir['*.rb'].each do |f|
+        require "#{path}/#{f}"
+   end
+   Dir.chdir(pwd)
+ end
+ 
+ 
+ 
+ public
+ def initialize(cgi = nil)
+   
+   $cgi = cgi || CGI.new
+   @cgi = $cgi
+
+   mk_config
+
+   @logger = Logger.new(@conf['LOG_PATH'] + "/messages")
+   $logger = @logger
+   $conf   = @conf
+   $app    = self
+
+   rescue RuntimeError => e
+     @cgi.out { "Error initializing the app: #{$!}" }
+ end
+
+ # this has to be public for testing scripts
+ public
+ def load_support_files # :nodoc:
+#   $stderr.puts "======== load support files ========="
+#   $stderr.puts "Inc Dir: #{App::config['include_directories'].inspect}"
+#   $stderr.puts "Path tr: #{@conf['PATH_TREE'].inspect}"
+#   $stderr.puts "====================================="
+   
+   base_path = @conf['APP_PATH']
+   @conf['PATH_TREE'].each do |t|
+       base_path << "/#{t}" 
+       (App::config['include_directories'] || []).each do |id|
+           include_files "#{base_path}/#{id}"
+        end
+   end
+
+#   (App::config['include_directories'] || []).each do |id|
+#         @conf['PATH_TREE'].each { |t| include_files @conf['APP_PATH'] + '/'+t+"/#{id}/"}
+#   end
+ end
+
+ public
+ def cgicall
+  script = @conf['SCRIPT']
+
+  
+  #
+  # 1st priority: Serve a file if it exists in the 'public' folder
+  #
+  file = @conf['PUBLIC_PATH'] + '/' + @conf['PATH_INFO']
+  if File.exists?(file) && File.ftype(file) == 'file' then
+    require 'cuca/mimetypes'
+    mt = MimeTypes.new
+    f = File.new(file)
+    extension = file.scan(/.*\.(.*)$/)[0][0] if file.include?('.')
+    extension ||= 'html'
+    mime = mt[extension] || 'text/html'
+    @cgi.out(mime) { f.read }
+    f.close
+    return
+  end
+
+
+  #
+  # 2nd: Check if we have a script for requested action
+  #
+  if (!File.exists?(script)) then
+    @cgi.out { "Script not found: #{script}" }
+    return
+  end
+
+
+  # 3rd: Load additional files
+  load_support_files
+
+
+  # 4th: Now let's run the actual page script code
+  controller_class_name = @conf['ACTION'].capitalize+"Controller"
+  
+  # Clear all hints
+  Widget::clear_hints()
+
+  # Load the code of the action into the module
+  controller_module = @urlmap.action_module
+
+
+  controller_module.module_eval(File.open(script).read, script)  unless \
+                  controller_module.const_defined?(controller_class_name.intern)
+
+  # Catch a common user error
+  if !controller_module.const_defined?(controller_class_name.intern) then 
+     @cgi.out { "Could not find #{controller_class_name} defined in #{script}" }
+     return
+  end
+
+  #
+  # Load the controller
+  #
+  begin
+
+     result = Sandbox.run(controller_class_name, @urlmap.action_module, @conf['ASSIGNS'], 
+                   $cgi.request_method, @conf['SUBCALL'])
+
+  
+     @cgi.out('type' => 'text/html') {result}
+
+  rescue Cuca::ApplicationException => e
+      err = "<b>Application Error: #{e}</b><br/>"
+      e.backtrace.each do |b|
+         err +="<br/>#{b}"
+      end
+      @cgi.out('status' => 'SERVER_ERROR') { err }
+      return 
+
+  rescue  => e
+      err = "<b>System Error: #{e}</b><br/>"
+      e.backtrace.each do |b|
+         err +="<br/>#{b}"
+      end
+      @cgi.out('status' => 'SERVER_ERROR') { err }
+      return 
+ 
+  end
+ end
+
+end
+
+
+end # module

data/lib/cuca/cgi_emu.rb

@@ -0,0 +1,67 @@
+# little fake cgi class that allows automated testing of cgi application
+
+class CGIEmu < CGI
+  class EnvTable
+    def initialize(options)
+     @test_path_info = options['PATH_INFO'] || '/'
+     @test_query_params = options['QUERY_PARAMS'] || {}
+    
+     the_env_table.each_pair { |k,v| ENV[k] = v }
+
+#     ENV.merge(the_env_table)
+    end
+
+    def query_string
+      r = [] 
+      @test_query_params.each_pair { |k,v| r << "#{k}=#{v}" }
+      return r.join('&')
+    end
+
+  
+    def the_env_table
+     {"SERVER_NAME"=>"localhost", 
+     "PATH_INFO"=>@test_path_info,
+     "REMOTE_HOST"=>"localhost", 
+     "HTTP_ACCEPT_ENCODING"=>"x-gzip, x-deflate, gzip, deflate",
+     "HTTP_USER_AGENT"=>"Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.8 (like Gecko)", 
+     "SCRIPT_NAME"=>"", 
+     "SERVER_PROTOCOL"=>"HTTP/1.1", 
+     "HTTP_ACCEPT_LANGUAGE"=>"en", 
+     "HTTP_HOST"=>"localhost:2000", 
+     "REMOTE_ADDR"=>"127.0.0.1", 
+     "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.8.6/2007-06-07)",
+     "HTTP_REFERER"=>"http://localhost:2000/",
+     "HTTP_COOKIE"=>"cuca_session=285715682bf030a19cb24b2560aabc36",
+     "HTTP_ACCEPT_CHARSET"=>"utf-8, utf-8;q=0.5, *;q=0.5",
+     "REQUEST_URI"=>"http://localhost:2000" + @test_path_info, 
+     "SERVER_PORT"=>"2000", 
+     "GATEWAY_INTERFACE"=>"CGI/1.1", 
+     "QUERY_STRING"=>query_string, 
+     "HTTP_ACCEPT"=>"text/html, image/jpeg, image/png, text/*, image/*, */*",
+     "SCRIPT_FILENAME"=>"/home/bones/workspace/cuca/scripts/../public/dispatch.cgi",
+     "REQUEST_METHOD"=>"GET", 
+     "HTTP_CONNECTION"=>"Keep-Alive"}
+    end
+
+    def [](key)
+ #     $stderr.puts "get FROM ENV_TABLE(#{key}) ==> #{the_env_table[key]}"
+      return the_env_table[key] || nil
+    end
+  end
+  
+  def env_table
+    EnvTable.new(@test_options)
+  end
+
+  def stdinput
+  #  $stderr.puts "Returning STDINPUT"
+    StringIO.new("")
+  end
+
+  def initialize(options)
+    @test_options = options
+    super()
+  end
+
+end
+

data/lib/cuca/cgi_fix.rb

@@ -0,0 +1,58 @@
+#!/usr/local/bin/ruby
+
+require 'cgi'
+
+# We'll add three methods to the cgi class in order to separete get/post requests:
+# * parameters -- all (mixed) get and post
+# * query_parameters -- get
+# * request_parameters -- post
+#
+class CGI # :nodoc:
+  class << self
+    def fix_env(ec)
+      if (ec['PATH_INFO'].nil? || ec['PATH_INFO'] == '') then
+         pi =  ec['REQUEST_URI']
+         pi = pi[0..(pi.index('?')-1)] if pi.include?('?')
+         ec['PATH_INFO'] = pi
+      end
+    
+      if (ec['QUERY_STRING'].nil? || ec['QUERY_STRING'] == '') then
+         ec['QUERY_STRING'] = ec['REQUEST_URI'].include?('?') ?
+             ec['REQUEST_URI'].scan(/.?\?(.*)/)[0][0] :
+             ""
+      end
+      ec
+    end
+  end 
+   
+   
+  def env_table
+    CGI::fix_env(ENV)
+    ENV
+  end
+
+  def parameters
+    query_parameters.merge(request_parameters)
+  end
+
+  def query_parameters
+     res = {}
+     query_string.split(/[&;]/).each do |p|
+              k, v = p.split("=")
+              v = '' if v.nil?
+              res[CGI.unescape(k)] = CGI.unescape(v)
+     end
+     res
+  end
+
+  def request_parameters
+   if request_method == 'POST' then
+     res = {}
+     params.each_pair { |k,v| res[k] = v[0] }
+     return res
+   else
+    return {}
+   end
+  end
+
+end

data/lib/cuca/const.rb

@@ -0,0 +1,3 @@
+module Cuca
+   VERSION = '0.0.1'
+end

data/lib/cuca/controller.rb

@@ -0,0 +1,240 @@
+module Cuca
+
+# :nodoc:
+class BreakControllerException < StandardError
+ # flags can be:
+ # :layout => 'new_layout' or false
+ # :redirect => '/to/new/url'	= dont render, just redirect
+ # :error => "something happend" = display an application error 
+attr_reader :flags
+ def initialize(flags = {})
+   @flags = flags
+ end
+end
+
+
+# === Cuca Controller
+#
+# A controller handles the get/post request for your website and has the ability to
+# generate an output directly making use of other Widgets and Layouts.
+#
+# The Controller class itself behaves just like Cuca::Widget, but instead of overwriting
+# the output method you must implement run or post or get or any combination.
+#
+# Additionally you can also define a wrapping layout (using the layout function) and you can
+# run code before a certain action is called using before_filter's.
+#
+# == Naming
+#
+# When you open a url like: http://your.website.com/users/list cuca will load the file /users/list.rb 
+# from your application path (usually app/users/list.rb). Within that file you must define one
+# class derrived from Cuca::Controller with name FilenameController. The /users/list.rb example must
+# therefor implement the ListController class.
+# 
+# == Subcalls
+#
+# Sometimes you might want to implement another URL that is logically joined with your
+# current page ("Ajax"?). To do this you can implement a (get|post|run)_subcallname method within
+# your controller. This one will get called if you open http://your.website.com/-controller-subcallname .
+#
+# == Routing / Pretty URL's
+#
+# Depending on your directory structure within the app folder you can define variable directory names 
+# that will hint you within the controller.
+#
+# Example:
+# File: app/user/__default_username/show.rb will map to http://user/johnrambo/show and define instance variable 
+# @username within the Controller defined in show.rb
+# 
+# The magic URL prefix (default: __default_) can be change within App::Config
+#
+# == Examples
+#
+# Hello world (index.rb):
+#
+#  class IndexController < Cuca::Controller
+#   def run
+#      content << "Hello World"
+#   end
+#  end
+# 
+# Using filters and layouts and generate page using the Markaby generator (fancy.rb):
+#
+#  require 'cuca/generators/markaby'
+#
+#  class FancyController < Cuca::Controller
+#    include Cuca::Generator::Markaby
+#    layout 'fancy'
+#    before_filter 'set_title'
+# 
+#    def set_title
+#      @page_title = "A Fancy Page"
+#    end
+# 
+#    def get
+#       mab do
+#          h1 "Welcome to the Fancy Page called #{@page_title}"
+#          p { text "Welcome to my"; b { paragraph } }
+#       end
+#    end
+#  end
+#
+# 
+class Controller < Widget
+
+ attr_reader :cancel_execution  # this can be set by anyone, 
+				# methods get/post/run will not be executed
+
+  def self.def_layout
+   begin
+     self.def_layout_name
+   rescue
+     nil
+   end
+ end
+
+ def self.layout(name)
+   define_attr_method(:def_layout_name,  name)
+ end
+
+ def self.before_filter(method)
+   begin
+     filters = self.def_before_filter
+     filters = "#{filters};#{method}"
+     define_attr_method(:def_before_filter, filters)
+   rescue => e
+     define_attr_method(:def_before_filter, method)
+   end
+ end
+
+ def run_before_filters
+#   $stderr.puts "Run  before filters"
+   begin 
+     before_filter = self.class.def_before_filter
+   rescue NoMethodError => e
+	# == no filters defined at all
+#        $stderr.puts " No before filters defined for #{self.class}"
+     return
+   end
+   before_filter.split(';').each do |filter| 
+     begin
+        if (!self.methods.include?(filter)) then
+          raise ApplicationException.new("Before filter method not defined: '#{filter}'")
+        end
+        ret = self.send(filter)
+        @cancel_execution = true if ret == false
+#     rescue NoMethodError => e
+#        raise ApplicationException.new "Before filter method not defined: '#{filter}'"
+     rescue BreakControllerException => bc
+        handle_exception(bc)
+     end
+   end
+ end
+
+
+ # this method will stop execution of the controller
+ # it's usefull to break somewhere in the middle or to 
+ # set a different layout
+ # flags can be
+ # :layout - Set a new layout
+ # :redirect - redirect to a different page
+ # :error - An error message (for application errors)
+ def stop(flags = {})
+   raise BreakControllerException.new(flags)
+ end
+
+ 
+ # this piece of code will handle a thrown exception BreakControllerException
+ def handle_exception(e)
+   if e.flags.has_key?(:layout) then
+       self.class.layout(e.flags[:layout])
+   end
+
+   if e.flags.has_key?(:redirect) then
+     self.class.layout false
+     to = e.flags[:redirect]
+     clear
+     @_content = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"><html><head><title>Redirecting...</title><meta http-equiv=\"REFRESH\" content=\"0;url=#{to}\"></HEAD></HTML>"
+     @cancel_execution = true
+   end
+
+   if e.flags.has_key?(:error) then
+     self.class.layout false
+     clear
+     @error_message = e.flags[:error]
+     @cancel_execution = true
+     mab { html { body { h2 "Error"; text @error_message }}}
+   end
+ end
+
+ private
+ # Overwrite this method to handle get and post events
+ def run
+ end
+ 
+ # Overwrite this method to handle get events
+ def get
+ end
+
+ # Overwrite this method to handle post events
+ def post
+ end
+
+
+
+ # This is the method as called from App. It will call 'get', 'post', 'run' and handle
+ # exceptions. what within [post,get,run]
+ # TOTHINKABOUT: run before filter from this method?
+ public
+ def _do(what, subcall)	
+   return if @cancel_execution
+   
+   method_name = what
+   method_name = "#{method_name}_#{subcall}" if subcall
+   begin
+      self.send(method_name) if self.methods.include?(method_name)
+   rescue BreakControllerException => e
+      handle_exception(e)
+   end
+ end
+
+
+ def initialize(*args)
+    # set a global variable of the controller object.
+    # Widgets can make use of this to call or modify the controller class.
+    $controller_object = self
+    
+    @cancel_execution = false
+    super(*args)
+
+    # FIXME: to think about...
+    get_assigns.each_pair do |k,v|
+      instance_variable_set("@#{k}", v)
+    end
+ end
+
+ private
+ def load_layout
+   return nil if self.class.def_layout.nil?
+   begin
+     layout_class = Object::const_get(self.class.def_layout.capitalize+"Layout")
+   rescue => e
+     # fixme - if layout loading fails we should display some error
+     return nil
+   end
+ end
+
+ public
+ def output
+   layout_class = load_layout
+   return content unless layout_class
+   c = content.to_s
+   a = get_assigns
+   a[:content_for_layout] = c
+   @_content = layout_class.new(:assigns=>a)
+ end
+end
+
+
+end # Module
+