cuca 0.06 → 0.07

data/lib/cuca/app_cgi.rb

@@ -0,0 +1,289 @@
+require 'logger'
+require 'cuca/config'
+
+
+def cuca_register_autoload(object, file)
+ autoload(object, file)
+end
+ 
+
+module Cuca
+
+module Objects
+end
+
+# 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 request_method
+       when 'POST' 
+            controller.send('_do'.intern, 'post', subcall)
+       when 'GET' 
+            controller.send('_do'.intern, 'get', subcall)
+   end
+
+   controller.run_after_filters
+
+   return [controller.http_status, controller.mime_type, controller.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
+
+
+ attr_reader :app_path, :log_path, :public_path, :urlmap, :cgi, :logger
+
+ @@app_config = Cuca::Config.new
+
+ ## Application configuration
+ public
+ def self.configure
+   yield @@app_config
+ end
+
+ def self.config
+   @@app_config
+ end
+
+ private
+ def init_app
+   @app_path    = $cuca_path + "/app"
+   @public_path = $cuca_path + "/public"
+   @log_path    = $cuca_path + "/log"
+   @app_path.freeze
+   @public_path.freeze
+   @log_path.freeze
+   @logger      = Logger.new("#{@log_path}/messages")
+ end
+
+
+ # Initializes settings to run the appliction
+ #
+ # @xxx_path - path to /app directory
+ private
+ def init_call(path_info)
+   require 'cuca/urlmap'
+   
+   begin
+     @urlmap = URLMap.new(@app_path, path_info)
+
+     rescue RoutingError => r # no script found - maybe serve a static file?
+      @urlmap = nil	# == no script found
+      return
+   end
+ 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
+
+ # this will schedule all files for autoloading
+ private
+ def autoload_files(path, naming_proc)
+   $app.logger.info "Autoload on #{path}"
+   return unless File.exist?(path)
+   pwd = Dir.pwd
+   Dir.chdir(path)
+   Dir['*.rb'].each do |f|
+        fn = f.scan(/(.*)\.rb/)[0][0]
+        classname = naming_proc.call(fn)
+        $app.logger.info "Scheduling Autoload Object '#{classname}' ==> #{path}/#{f}"
+        cuca_register_autoload(classname.intern, "#{path}/#{f}")
+   end
+   Dir.chdir(pwd)
+ end
+
+ public
+ def initialize
+   $app    = self
+   init_app
+ end
+
+ # this will yield all support directories from base path and if defined
+ # the naming proc else nil
+ def all_support_directories(path_tree)
+   path_tree.each do |t|
+       (App::config['include_directories'] || []).each do |id|
+          if id.instance_of?(Hash) then 
+              yield "#{t}/#{id[:dir]}", id[:class_naming]
+          else 
+	      yield "#{t}/#{id}", nil
+          end
+       end
+   end  
+ end
+
+ public
+ def load_support_files(urlmap)  # :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 "====================================="
+   
+#   db = $:.dup
+#   all_support_directories(@conf['APP_PATH'])  { |d,p| $: << d }
+
+#   all_support_directories(@app_path, @urlmap.path_tree) do |dir, proc|
+#    $stderr.puts "PATH TREE: #{urlmap.path_tree.inspect}"
+   all_support_directories(urlmap.path_tree) do |dir, proc|
+#     $stderr.puts "Support Directory #{dir}"
+     if proc then
+        autoload_files(dir, proc)
+     else
+        include_files(dir)
+     end   
+   end
+ end
+
+
+ # this will build an error message depending on configuration
+ private
+ def get_error(title, exception, show_trace = true, file=nil)
+   err = "<h3>#{title}</h3>"
+   err << "<b>#{exception.class.to_s}: #{CGI::escapeHTML(exception.to_s)}</b><br/>"
+   $stderr.puts "ERROR: #{title} - #{exception.class.to_s}: #{exception.to_s}"
+   if (show_trace) then
+      exception.backtrace.each do |b|
+         $stderr.puts "   #{b}" 
+         err +="<br/>#{b}"
+      end
+   else
+      begin
+         err = File.open(file).read
+      rescue
+      end
+   end
+   err
+ end
+
+
+ public
+ def cgicall(cgi = nil)
+  @cgi = cgi || CGI.new
+  
+
+  #
+  # 1st priority: Serve a file if it exists in the 'public' folder
+  #
+  file = @public_path + '/' + @cgi.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('type' => mime, 
+             'expires' => (Time.now+App.config['http_static_content_expires'])) { f.read }
+    f.close
+    return
+  end
+
+  init_call(@cgi.path_info)
+
+  # If config (urlmap) couldn't find a script then let's give up
+  # with a file-not-found 404 error
+  if @urlmap.nil? then
+     begin
+      file = "#{@public_path}/#{Cuca::App.config['http_404']}"
+      c = File.open(file).read
+      @cgi.out('status' => 'NOT_FOUND', 'type' => 'text/html') { c }
+     rescue => e
+      @cgi.out('status' => 'NOT_FOUND', 'type' => 'text/html') { "404 - File not found!" }
+     end
+     return
+  end
+
+  logger.info "CGICall on #{@urlmap.url} - #{@urlmap.script}"
+  script = @urlmap.script
+
+  #
+  # 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(@urlmap)
+
+  test = ApplicationController.new
+
+
+  # 4th: Now let's run the actual page script code
+  controller_class_name = @urlmap.action.capitalize+"Controller"
+  
+  # Clear all hints
+  Widget::clear_hints()
+
+  # Load the code of the action into the module
+  controller_module = @urlmap.action_module
+
+
+  # things fail in this block get error logged and/or displayed in browser
+  begin
+     # load controller
+     controller_module.module_eval(File.open(script).read, script)  unless \
+                  controller_module.const_defined?(controller_class_name.intern)
+
+     # Catch a common user error
+     raise Cuca::ApplicationException.new("Could not find #{controller_class_name} defined in #{script}") \
+          unless controller_module.const_defined?(controller_class_name.intern)
+
+
+     # run controller
+     (status, mime, content) = Sandbox.run(controller_class_name, 
+                           @urlmap.action_module, @urlmap.assigns, 
+                           @cgi.request_method, @urlmap.subcall)
+  
+     logger.info "CGICall OK"
+     @cgi.out('type' => mime, 'status' => status) {content}
+
+  rescue Cuca::ApplicationException => e
+      err = get_error("Application Error", e,
+              Cuca::App.config['display_errors'], Cuca::App.config['http_500'])
+      @cgi.out('status' => 'SERVER_ERROR') { err }
+
+     logger.info "CGICall Application Error"
+      return
+
+  rescue  => e
+      err = get_error("System Error", e, 
+              Cuca::App.config['display_errors'], Cuca::App.config['http_500'])
+      @cgi.out('status' => 'SERVER_ERROR') { err }
+
+      logger.info "CGICall System Error"
+      return 
+ 
+  end
+ end
+
+end
+
+
+end # module

data/lib/cuca/config.rb

@@ -1,6 +1,6 @@
 module Cuca
 
- # == Configure the application
+ # = 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.
  #
@@ -10,21 +10,14 @@ module Cuca
  #      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} )
- #  Optionally it's possible to autoload these support files. To do this you must pass an 
- #  array of hashes to the method with the following keys:
- #    - :dir The name of the directory (e.g. _controllers)
- #    - :class_naming A proc that will take one parameter and returns the name of the class
- #      found within the file. It will get the filename as parameter.
- #      example :class_naming => Proc.new { |file_name| file_name.capitalize+'Controller' }
- # * log_level - default 3 (future?)
- # * magic_prefix - default: '__default_' (see Cuca::Controller)
- # * display_errors - default: true , display errors in browser (swith off within production systems)
+ #
+ # == Attributes:
+ # 
+ # The file *conf/environment.rb* within your application path contains a full list of
+ # attributes you can set.
+ #
+ 
  class Config < Hash
    def method_missing(m, *params)
        met = m.id2name

data/lib/cuca/controller.rb

@@ -13,7 +13,7 @@ attr_reader :flags
 end
 
 
-# === Cuca Controller
+# = 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.
@@ -46,7 +46,7 @@ end
 # 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
+# The magic URL prefix (default: __) can be change within App::Config
 #
 # == Defining a Layouts
 #
@@ -69,6 +69,12 @@ end
 # that allows you to redirect, display error or set a different layout.
 #
 #
+# == Filters
+#
+# A filter method can be run before or after the controller code is executed. It can be used
+# to prepare data, restrict access or format the generated content for example.
+# See: before_filter and after_filter
+#
 # == Examples
 #
 # Hello world (index.rb):
@@ -121,11 +127,17 @@ class Controller < Widget
   @_http_status
  end
 
+ # Add additional http header for the response
+ # No validation made
+ def http_header(field=nil, value=nil)
+   @_http_header ||= {}
+   @_http_header[field] = value if field
+   @_http_header
+ end
 
  # get layout
  private	# ??
  def self.def_layout
-#   return @_layout unless @_layout.nil?
    self.run_attr_method('def_layout_name')
  end
 
@@ -203,7 +215,7 @@ class Controller < Widget
      break if @cancel_execution
      filter = f[0]
      begin
-       if (!self.methods.include?(filter)) then
+       if (!self.respond_to?(filter.intern)) then
            http_status "SERVER_ERROR"
            raise ApplicationException.new("Filter not found in chain #{debug_filter_names}: #{filter}")
        end
@@ -280,6 +292,10 @@ class Controller < Widget
      end
      mab { html { body { h2 "Error"; text @error_message; br; text trace }}}
    end
+   
+   if e.flags.has_key?(:cancel_execution) then
+     @cancel_execution = true
+   end
  end
 
  def action_name
@@ -311,7 +327,7 @@ class Controller < Widget
    method_name = what
    method_name = "#{method_name}_#{subcall}" if subcall
    begin
-      self.send(method_name) if self.methods.include?(method_name)
+      self.send(method_name) if self.respond_to?(method_name.intern)
    rescue BreakControllerException => e
       handle_exception(e)
    rescue ApplicationException => e
@@ -321,10 +337,6 @@ class Controller < Widget
 
 
  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)
 
@@ -346,8 +358,7 @@ class Controller < Widget
    begin
      layout_class = Object::const_get(lname)
    rescue => e
-     # fixme - if layout loading fails we should display some error
-     raise ApplicationException.new("Could not load layout: #{lname}: #{e}")
+     raise ApplicationException, "Could not load layout: #{lname}: #{e}"
      return nil
    end
  end

data/lib/cuca/generator/view.rb

@@ -1,5 +1,5 @@
 require 'erb'
-
+require 'cuca/generator_context'
 
 module Cuca
 module Generator
@@ -40,53 +40,7 @@ module Generator
 #
 module View
 
-  class AssignBindings # :nodoc:
-    def get_bindings
-       binding
-    end
-
-    def initialize(assigns, base_object)
-      assigns.each_pair do |k,v|
-         instance_variable_set("@#{k}", v)
-      end
-      @base = base_object
-    end
-        
-    def method_missing(sym, *args, &block )
-      class_name = sym.id2name
-
-         
-      # 1st try to find method in the base widget
-      if @base.methods.include?(class_name) then 
-            return @base.send(class_name, *args, &block)
-      end
-      c = nil
-      # 2nd try to find a widget
-      if Object.const_defined?(class_name+'Widget') then
-           c = Object::const_get(class_name+'Widget')
-      else
-           # ...try to find in action namespace
-           mod = $app.urlmap.action_module
-           c = mod.const_get(class_name+'Widget') if mod.const_defined?(class_name+'Widget')
-      end
-         
-      raise NameError.new "Undefined method: #{class_name}" unless c
- 
-      widget = c.new({:args => args,
-                    :assigns => @assigns },
-                    &block)
-
-#     $stderr.puts "Widget:" + widget.inspect
-      return widget.to_s
-
-#     $stderr.puts "Good"
-    end
-  end  
-  
-#  VIEW_DIR = $cuca_path+'app/_views'
-
-  
-  # Procuce content by a template file.
+  # Produce content by a template file.
   # This will return the generated markup as a string
   def viewtext(filename=nil)
     view_dir = $cuca_path + '/' + App::config['view_directory']
@@ -105,13 +59,13 @@ module View
 
   # Procuce content and append to widget.
   def view(filename)
-     @_content << viewtext(filename)
+     @_content << viewtext(filename)  
   end
   
   # Normally you have your view (the template) within a separate file. Nevertheless
   # you can passing as a string to this function.
   def viewtext_p(template)
-    ERB.new(template).result(AssignBindings.new(get_assigns, self).get_bindings)
+    ERB.new(template).result(GeneratorContext.new(get_assigns, self).get_bindings)
   end
   
   # Equivaltent to view but take template as a string.
@@ -123,4 +77,3 @@ end
 
 end # Mod: Generator
 end # Mod: Cuca
-