cuca 0.01

data/lib/cuca/urlmap.rb

@@ -0,0 +1,267 @@
+
+if __FILE__ == $0  then
+ require 'rubygems'
+ require 'cuca'
+end
+
+module Cuca
+
+# URLMap will throw this in case we can't find a controller
+# file for a URL.
+class RoutingError < StandardError	# :nodoc:
+end
+
+
+# == URLMap 
+#
+# URLMap is used internally to match a URL to a controller file.
+# Call with ds = URLMap.new('/path/to/app', 'path/from/url')
+#
+# You can then fetch the following values:
+#
+# * script 		- path to the controller file
+# * assigns 		- hash with variable assigns from the url (magick prefixes)
+# * subcall 		- name of subcall or nil if a normal call was made
+# * action 		- Action name (Note: action.capitalize+"Controller" is your controller class name)
+# * action_path 	- Path to the action
+# * action_path_full 	- Full path to application
+# * action_module	- The module the action should be loaded into (to avoid name conflicts, depends on action_path)
+#
+#
+# == Match on other URL
+#
+# A widget/controller can make use of the URLMap object to scan on other directories (example to find out if a
+# link url will be withing the same controller).
+#
+# See match? / submatch? and usubmatch?
+#
+#
+# == Notes
+#
+# URL's ending with '/' will be scanned for default index files.
+#
+# URL's where last part (action) starts with '-' will be scanned for
+# subcalls
+#
+# If no script is found or any other error it will raise a RoutingError exception
+#
+#
+# == Example
+#
+#  u = URLMap.new('/home/bones/src/cuca_app/app', 'customer/southwind_lda/show'
+#  
+#  u.script 	 => '/home/bones/src/cuca_app/app/customer/__customer/show.rb'
+#  u.action 	 => 'show'
+#  u.assigns 	 => { 'customer' => 'southwind_lda' }
+#  u.action_path => 'customer/southwind_lda/'
+#
+class URLMap
+ attr_reader :assigns
+ attr_reader :script
+ attr_reader :subcall
+ attr_reader :action
+ attr_reader :action_path
+ attr_reader :action_path_full
+ attr_reader :action_module
+ 
+ DEF_ACT = Cuca::App::config['magic_action_prefix'] || '__'
+ DEF_IDX = [ 'index', 'default' ]
+
+ private 
+ def scan_file(base, file)
+
+   if (file == '') then 	# check for default index file
+     DEF_IDX.each do |idxfile|
+       if File.exist?("#{base}/#{idxfile}.rb")
+          @action = idxfile
+          return "#{idxfile}.rb"
+       end
+     end
+     raise RoutingError.new("No default index file found in #{base}")
+   end
+   
+   @action = file
+   
+   # check if a regular file exists:
+#   puts "Checking file on #{check}"
+   return (file+".rb") if File.exist?("#{base}/#{file}.rb")
+   
+   # check if the subcall file exists:
+   if (file[0].chr == '-') then
+      (action,subcall) = file.scan(/^\-(.*)\-(.*)$/).flatten
+      if action.nil? || subcall.nil? || action.strip.empty? then
+        raise RoutingError.new("Bad format on subcall: #{file}")
+      end
+      raise RoutingError.new("Script not found for subcall: #{file}: #{action}.rb") if !File.exist?("#{base}/#{action}.rb")
+      @subcall = subcall
+      @action = action
+      return "#{action}.rb"
+   end 
+ end
+
+ private
+ def scan_dir(base, file)
+   return file if File.directory?("#{base}/#{file}")
+   
+   d = Dir["#{base}/#{DEF_ACT}*"].collect { |f| f.split('/').last }
+
+#   puts "Directory not found, checking for default in #{base}  - #{file}"
+
+#   puts d.inspect
+#   
+   raise RoutingError.new("Multiple default actions defined in #{base}") if  d.size > 1 
+   raise RoutingError.new("Routing Error in #{base}") if d.empty?
+
+
+   @assigns[d[0][DEF_ACT.size..-1]] = file   
+   d[0]  
+ end
+
+
+ private
+ def make_module(path)
+   const_name = "Appmod_#{path.gsub(/[\/\\]/, '_')}"
+   
+   if Cuca::const_defined?(const_name.intern) then
+     return Cuca::const_get(const_name.intern)
+   end
+ 
+   m = Module.new
+   Cuca::const_set(const_name.intern, m)
+   return m
+ end
+
+
+ # scan will match an URI to a script and set assigns. (called from initialize)
+ private
+ def scan
+   files = @path_info.split('/')
+   
+   files << '' if @path_info[@path_info.size-1].chr == '/'		# add empty element if we point to a directory
+   
+#   puts files.inspect  
+   real_path = @base_path
+   
+   # scan directory
+   files.each_index do |idx| 
+     next if idx >= (files.size-1)  # skip last element
+     r = scan_dir(real_path, files[idx])
+     raise RoutingError.new("Routing Error at #{real_path} - #{files[idx]}") if !r
+     real_path = "#{real_path}/#{r}"     
+   end
+
+   @action_path       = real_path[@base_path.length..-1]
+   @action_path_full  = real_path 
+   @action_module     = make_module(@action_path)
+   
+   # scan file (last element)
+   r = scan_file(real_path, files.last)
+
+   raise RoutingError.new("Routing Error - script not found at #{real_path} - #{files.last}") if !r
+   
+   real_path = "#{real_path}/#{r}"
+  
+   @script = File.expand_path(real_path)
+   self
+ end
+
+ 
+ # match will check if the supplied url maches with a script
+ # returns boolean
+ #
+ # Example: 
+ #  URLMap('/path/to/app', '/customer/southwind_lda/').match?('/path/to/app/customer/__custid/index.rb') => true
+ public
+ def match?(script)
+   m_script = @script
+   p_script = File.expand_path(script)
+   
+#   $stderr.puts "URLMap::match - #{m_script} - #{p_script}"
+   return (m_script == p_script)
+   rescue RoutingError
+     false
+ end
+ 
+
+ # this will match if the current script can be found within a path
+ # from the parameters.
+ #
+ # Example:
+ #  URLMap('/path/to/app', '/customer/southwind_lda/').submatch?('/customer/__custid/') => true 
+ public
+ def submatch?(some_path)
+#    $stderr.puts "Submatch: #{some_path} with #{@script} - #{(@script.length < some_path.length).inspect} #{@script.include?(some_path)}"
+    return false if @script.length < some_path.length
+    return @script.include?(some_path)
+ end
+ 
+ # this will match the current script to a part of a url (link):
+ #
+ # Example:
+ #  URLMap('/path/to/app', '/customer/southwind_lda/').submatch?('/customer/other_customer/') => true 
+ public
+ def usubmatch?(some_path)
+    @path_info.include?(some_path)
+ end
+
+ # FIXME: needed?
+ public
+ def has_script?(script)
+    return !(@script == '')
+ end
+ 
+
+ def initialize(base_path, path_info, default_actions = ['index'])
+   @path_info = path_info
+   @base_path = base_path
+   @script    = ''
+   @subcall   = nil
+   @default_actions = default_actions
+   @assigns = {}
+   @action = ''
+   @action_path = ''
+   scan
+   self
+ end
+
+end
+
+end
+
+
+#
+# Testings:
+#
+
+if __FILE__ == $0  then
+require 'app'
+ 
+ BASE = '/home/bones/src/cuca/app'
+ URL  = 'user/martin/'
+ 
+ puts "Testing on '#{BASE}' - '#{URL}'"
+ 
+ module Cuca
+  ds = URLMap.new(BASE, URL)
+ begin
+  rescue RoutingError => e
+  puts "E: Invalid request #{$!}"
+ end
+
+
+
+  puts "Match with: #{ds.match?('/home/bones/src/cuca/app/user/__default_username/index.rb')}"
+  puts "Submatch with /user/__username/ #{ds.submatch?('/user/__username/')}"
+  puts "Submatch with '/user/' #{ds.submatch?('/user/')}"
+  puts "USubmatch with '/user/' #{ds.usubmatch?('/user/martin')}"
+  puts
+  puts "Script is:        #{ds.script}"
+  puts "Assigns are:      #{ds.assigns.inspect}"
+  puts "Subcall:          #{ds.subcall.inspect}"
+  puts "Action:           #{ds.action}"  
+  puts "Action Path:      #{ds.action_path}"
+  puts "Action Path Full: #{ds.action_path_full}"
+  puts "Action Module:    #{ds.action_module.inspect}"
+  end
+  
+end

data/lib/cuca/widget.rb

@@ -0,0 +1,212 @@
+module Cuca
+# === Widget
+#
+# All elements that generate content (e.g. html) are widgets. To implement a widget create
+# a class derrived from Cuca::Widget and overwrite the +output+ method. The output method 
+# can take any argument or blocks - whatever you need to build your content. At the end you 
+# should write your result to @_content. For this it is advisable to use the content accessor 
+# or any of the Cuca::Generator 's. 
+#
+# == Variables
+#
+# Instance variables shall be used by sub-widgets and generators. You can fetch them 
+# with get_assigns.
+#
+# == Naming
+#
+# Name all widgets like YournameWidget - when using them in a generator simply call them
+# without the 'Widget' and directly with the paramenters of the output.
+#
+# == Examples
+# An example widget without a generator:
+#
+#  class BigfontWidget < Cuca::Widget
+#    def output(text_to_print)
+#       content << "<b><i>#{text_to_print}</i></b>"
+#    end
+#  end
+#
+#
+# Example with the Markaby Generator - makes use of the BigfontWidget example above
+#
+#  require 'cuca/generators/markaby'
+#
+#  class HeadlineWidget < Cuca::Widget
+#   include Cuca::Generator::Markaby
+#
+#   def output(text_to_print)
+#     @t = text_to_print		# only instance variables are visisble to generators  
+#     mab { div.headline { Bigfont(@t) }} 
+#   end
+#  end
+#
+class Widget
+
+  # An accessor to @_content
+  # All 'generators' (like the mab -function) should append their
+  # generated clear text to @_content, latest with the before_to_s method
+  def content
+    @_content
+  end
+  
+  # overwrite the content
+  def content=(newval)
+    @_content = newval
+  end
+  
+
+  # an accessor to the current controller object - if available, otherwise nil
+  def controller
+    $controller_object || nil
+  end
+
+  # Hints is shared a shared container for all widgets. If you want to pass an information
+  # from one widget to another this can be useful.
+  # The last widget renered is the controller, then the Layout.
+  def hints
+    @@_hints
+  end
+
+  # clear all hints
+  def self.clear_hints
+    @@_hints = {}
+  end
+  
+  # An accessor to the global cgi variables
+  def cgi
+   $cgi
+  end
+
+  # An accessor to the global logger variables
+  def log
+   $logger
+  end
+
+  # An accessor to the Cuca::app object
+  def app
+   $app
+  end
+  
+
+  # an accessor to cgi.parameters variables. This is NOT params from the CGI class 
+  # (see cgi_fix)
+  def params
+    $cgi.parameters
+  end
+  
+  # accessor to cgi query parameters (http GET)
+  def query_parameters
+     $cgi.query_parameters
+  end
+  
+  # accessor to the cgi request parameters (http POST)
+  def request_parameters
+    $cgi.request_parameters
+  end
+  
+  # an accessor to request_method
+  def request_method
+    return $cgi.request_method
+  end
+
+  # Escape a string to use with URL etc..
+  def escape(text)
+    CGI::escape(text)
+  end
+
+  # Unescape an escaped string
+  def unescape(text)
+    CGI::unescape(text)
+  end
+
+  # escape a string on HTML codes
+  def escapeHTML(text)
+    CGI::escapeHTML(text)
+  end
+  
+  # unescape an html escaped string
+  def unescapeHTML(text)
+   CGI::unescapeHTML(text)
+  end
+
+  
+  # initialize - don't use widgets directly with .new.
+  #
+  # params[:assigns] variables in form of hash(var=>val) to make available to
+  # the generator blocks if they require/need
+  # params[:args] will be passed to the output method
+  # block will also be passed to the output method
+  def initialize(params = {}, &block)
+   @_assigns = params[:assigns] || {} 
+   @_args = params[:args] || {}
+   @_profiler = params[:profiler] || nil
+   @_block = block
+   @_content = ""
+
+   @@_hints ||= {}
+  end
+  
+  # will fetch a list of assigns to be passed to a code generator block
+  # this includes the :assigns from the constructor plus all instance
+  # variables from the widget
+  def get_assigns
+    a = @_assigns.clone
+
+    self.instance_variables.each do |v|
+      next if v.match(/^\@\_/)
+      next if v.include?('cancel_execution')		# this is some internal key
+      a[v.gsub(/\@/,'')] = self.instance_variable_get(v)
+    end
+    return a
+  end
+
+  # clear widgets generated content
+  def clear
+   @_content = ""
+  end
+
+
+  # Overwrite this method with a function that takes the arguments and optionally
+  # a block as you like.
+  def output(*args, &block)
+    @_content = "This widget doesnt have any content"
+  end
+
+  
+  # this method can be implemented by the generator
+  # to do finishing touches to @_content. Will be called before
+  # @content.to_s is returned to the controller/App
+#  def before_to_s
+#  end
+
+  # get cleartext for the widget
+  def to_s
+    if @_profiler then 
+       require 'profiler'
+       Profiler__::start_profile
+    end
+       
+    output(*@_args, &@_block)
+    before_to_s if self.methods.include?('before_to_s')
+    content = @_content.to_s
+
+    if @_profiler then
+        Profiler__::stop_profile
+        @_profiler.puts "____________________PROFILER #{self.class.inspect} ______________________"
+        Profiler__::print_profile(@_profiler)
+    end
+
+    return content
+  end
+
+
+  # this can be used by derrived classes
+  def self.define_attr_method(name, value=nil)
+    sing = class << self; self; end
+    sing.class_eval "def #{name}; #{value.inspect}; end"
+#  $stderr.puts "def #{name}; #{value.to_s.inspect}; end"
+  end
+
+end
+
+end # Module

data/lib/cuca.rb

@@ -0,0 +1,68 @@
+# == Cuca - a widget-based web framework
+#
+# Cuca is a small web development framework mainly designed to build
+# applications - there is little focus on design but more on coding
+# efficiency.
+#
+# It implements the following concepts:
+# * A Widget is a screen element. Can be a full page or part of it.
+#   The Controller and the Layout are Widgets, too.
+# * A Controller deals with one request URI (get, post or both)  and can set variables
+#   other widgets can make use of. It can also define a Layout and filters.
+# * A Layout wraps the output of a controller and finally return the
+#   built web page.
+# * A Generator (NOT "code generator") can be used within any Widget to help building the web content.
+#   Cuca comes with a Markaby and eruby Generator.
+# * A Session can used optionally to keep stateful data.
+#
+#
+# When you 'require' cuca you must set the global varibale $cuca_path to the root of your 
+# application structure. This is normally done by your dispatch.cgi or dispatch.fcgi 
+# script that comes with the cuca application skeleton.
+#
+# === See also
+#
+# * Cuca::Widget
+# * Cuca::Controller
+# * Cuca::Layout
+# * Cuca::Session
+# * Cuca::App
+
+require 'cgi'
+require 'cuca/cgi_fix'
+require 'rubygems'
+
+# All Classes are defined under this namespace
+module Cuca
+
+class CucaException < Exception # :nodoc:
+end
+
+# Any error on the application
+class ApplicationException < Exception
+end
+
+end
+
+
+if $cuca_path.nil? then
+ $stderr.puts "WARN: $cuca_path not found, assuming #{Dir.pwd}"
+ $cuca_path = Dir.pwd
+end
+
+require 'cuca/const'
+
+$cuca_path = File.expand_path($cuca_path) + '/'
+
+require 'cuca/app'
+
+$LOAD_PATH << $cuca_path+'/lib'
+begin 
+ require $cuca_path+'/conf/environment'
+rescue LoadError => e
+ $stderr.puts "WARN: Error loading conf/environment: #{e}"
+end
+
+require 'cuca/widget'
+require 'cuca/controller'
+require 'cuca/layout'

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: cuca
+version: !ruby/object:Gem::Version 
+  version: "0.01"
+platform: ruby
+authors: 
+- Martin Boese
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: markaby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.5"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fcgi
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.7
+    version: 
+description: Cuca is a light web development framework that supports CGI and FastCGI. It has  a widget-bases approach to reuse functionality and does not implement an MVC architecture. Content  can be generated directly by the controller with the help of external widgets that can generate code using  markaby, eruby or any other user implemented 'generator'. It supports pretty URL's, layouts,  sessions and the rendering of 'partials'.
+email: boesemar@gmx.de
+executables: 
+- cuca
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/cuca
+- lib/cuca.rb
+- lib/cuca
+- lib/cuca/cgi_fix.rb
+- lib/cuca/controller.rb
+- lib/cuca/stdlib
+- lib/cuca/stdlib/arview.rb
+- lib/cuca/stdlib/form.rb
+- lib/cuca/stdlib/link.rb
+- lib/cuca/stdlib/slink.rb
+- lib/cuca/stdlib/arform.rb
+- lib/cuca/stdlib/listwidget
+- lib/cuca/stdlib/listwidget/querydef.rb
+- lib/cuca/stdlib/listwidget/dblist.rb
+- lib/cuca/stdlib/listwidget/staticdatalist.rb
+- lib/cuca/stdlib/listwidget/list.rb
+- lib/cuca/stdlib/list.rb
+- lib/cuca/stdlib/formerrors.rb
+- lib/cuca/generator
+- lib/cuca/generator/markaby.rb
+- lib/cuca/generator/view.rb
+- lib/cuca/sessionflash.rb
+- lib/cuca/widget.rb
+- lib/cuca/mimetypes.rb
+- lib/cuca/test
+- lib/cuca/test/helpers.rb
+- lib/cuca/sessionpage.rb
+- lib/cuca/session.rb
+- lib/cuca/cgi_emu.rb
+- lib/cuca/app.rb
+- lib/cuca/urlmap.rb
+- lib/cuca/layout.rb
+- lib/cuca/const.rb
+- application_skeleton/log
+- application_skeleton/log/messages
+- application_skeleton/log/error.log
+- application_skeleton/log/access.log
+- application_skeleton/README
+- application_skeleton/tests
+- application_skeleton/tests/widgets
+- application_skeleton/tests/widgets/link.rb
+- application_skeleton/app
+- application_skeleton/app/index.rb
+- application_skeleton/app/demo.rb
+- application_skeleton/app/_controllers
+- application_skeleton/app/_controllers/application.rb
+- application_skeleton/app/_layouts
+- application_skeleton/app/_layouts/simple.rb
+- application_skeleton/app/_widgets
+- application_skeleton/app/_widgets/test.rb
+- application_skeleton/app/_widgets/sourcecode.rb
+- application_skeleton/app/user
+- application_skeleton/app/user/__default_username
+- application_skeleton/app/user/__default_username/index.rb
+- application_skeleton/app/_views
+- application_skeleton/scripts
+- application_skeleton/scripts/server-lighttpd-fcgi.rb
+- application_skeleton/scripts/console.rb
+- application_skeleton/scripts/test.rb
+- application_skeleton/scripts/server-lighttpd.rb
+- application_skeleton/scripts/server-webrick.rb
+- application_skeleton/scripts/console
+- application_skeleton/lib
+- application_skeleton/public
+- application_skeleton/public/dispatch.fcgi
+- application_skeleton/public/dispatch.cgi
+- application_skeleton/public/css
+- application_skeleton/public/css/style.css
+- application_skeleton/public/img
+- application_skeleton/public/img/cuca-seagull.png
+- application_skeleton/conf
+- application_skeleton/conf/environment.rb
+has_rdoc: true
+homepage: http://cuca.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cuca
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: A widget-based web framework
+test_files: []
+