cuca 0.03 → 0.04

data/lib/cuca/cgi_emu.rb

@@ -1,6 +1,10 @@
 # little fake cgi class that allows automated testing of cgi application
 
 class CGIEmu < CGI
+   
+  attr_reader :out_params
+  attr_reader :out_content
+
   class EnvTable
     def initialize(options)
      @test_path_info = options['PATH_INFO'] || '/'
@@ -63,5 +67,10 @@ class CGIEmu < CGI
     super()
   end
 
+  def out(params, &block)
+    @out_params = params
+    @out_content = block.call
+  end
+
 end
 

data/lib/cuca/cgi_fix.rb

@@ -55,4 +55,14 @@ class CGI # :nodoc:
    end
   end
 
+ # cgi implementation test
+ def cgidump
+   s = ""
+   s << "-----ENV------<br>"
+   self.env_table.each_pair { |k,v| s << "#{k} => #{v}<br>" }
+   s << "--------------<br>"
+   s << "Server Software: #{self.server_software}<br>"
+   s << "PATH INFO: #{self.path_info}<br>"      
+ end
+
 end

data/lib/cuca/config.rb

@@ -0,0 +1,67 @@
+module Cuca
+
+ # == 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} )
+ #  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)
+ class Config < Hash
+   def method_missing(m, *params)
+       met = m.id2name
+
+   #    raise NoMethodError 
+       if met[met.size-1].chr == '=' then
+         self[met[0..met.size-2]] = params[0]
+         return
+       end
+
+       if met[-2..-1] == '<<' then
+         self[met[0..met.size-3]] ||= []
+         self[met[0..met.size-3]] << params[0]
+         return
+       end
+
+       return self[met] unless self[met].nil?
+  
+      raise NoMethodError
+   end
+   
+   # some default stuff
+   def initialize
+     self['include_directories'] = %w{_controllers _widgets _layouts}
+     self['log_level']  = 3
+     self['magic_prefix'] = '__default_'
+     self['session_key'] = 'cuca_session'
+     self['session_prefix'] = 'cuca.'
+     self['session_valid'] = 3600*24
+     self['view_directory'] = 'app/_views'	# where to find views for the view/erb generator
+     self['http_404'] = '404.html'
+     self['http_500'] = '500.html'
+     self['default_mime_type'] = 'text/html'
+     self['display_errors'] = true
+     self['http_static_content_expires'] = 300	# expires http header for static content (only if served by the dispatcher)
+   end
+   
+ end
+
+end

data/lib/cuca/const.rb

@@ -1,3 +1,3 @@
 module Cuca
-   VERSION = '0.03'
+   VERSION = '0.04'
 end

data/lib/cuca/controller.rb

@@ -22,7 +22,7 @@ end
 # 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.
+# run code before and after a certain action is called using before/after_filter's.
 #
 # == Naming
 #
@@ -95,8 +95,10 @@ end
 # 
 #    def get
 #       mab do
-#          h1 "Welcome to the Fancy Page called #{@page_title}"
-#          p { text "Welcome to my"; b { paragraph } }
+#          h1 { "Welcome to the Fancy Page called #{@page_title}" }
+#          p { text "Welcome to my" 
+#             b { "paragraph" } 
+#          }
 #       end
 #    end
 #  end
@@ -142,50 +144,72 @@ class Controller < Widget
 
 
  private
- def self.define_filter_method(chain_name, method_name)
+ def self.define_filter_method(chain_name, method_name, priority=50)
    begin
      filters = self.send(chain_name)
-     filters = "#{filters};#{method_name}"
+     filters = "#{filters};#{method_name}|#{priority.to_s}"
      define_attr_method(chain_name, filters)
    rescue NoMethodError => e
-     define_attr_method(chain_name, method_name)
+     define_attr_method(chain_name, "#{method_name}|#{priority.to_s}")
    end
  end
 
  # One or more before filter can set by an application Controller
  # The instance methods will be run before the action get ran (get/post/run)
+ # If you have many filters and need order you can set the priority option.
+ # Lower priorities will be ran first.
  public
- def self.before_filter(method)
-    define_filter_method(:def_before_filter, method)
+ def self.before_filter(method, priority = 50)
+    define_filter_method(:def_before_filter, method, priority)
  end
 
  # Priority before filters will be ran before any before filters
- # this should be only used internally
+ # this should be only used internally or for core extension
  public
  def self.priority_before_filter(method)
    define_filter_method(:def_priority_before_filter, method)
  end
 
+ # Priority after filters will be ran after any after filters
+ # this should be only used internally or for core extension
+ # also this gets called no matter if anyone raises :stop method
+ public
+ def self.priority_after_filter(method)
+   define_filter_method(:def_priority_after_filter, method)
+ end
+
  # after_filter - get run after the controller action has be executed
+ # If you have many filters and need order you can set the priority option.
+ # Lower priorities will be ran first.
  public
- def self.after_filter(method)
-   define_filter_method(:def_after_filter, method)
+ def self.after_filter(method, priority = 50)
+   define_filter_method(:def_after_filter, method, priority)
  end
 
  private
  def run_filters(chain_name, debug_filter_names)
-   filters = self.class.run_attr_method(chain_name.to_s)
-   return if filters.nil?
-   filters.split(';').each do |filter|
-      next if filter.strip == ''
-
-      begin
-          if (!self.methods.include?(filter)) then
-              raise ApplicationException.new("Filter not found in chain #{debug_filter_names}: #{filter}")
-          end
-#          $stderr.puts "Running Filter (#{debug_filter_names}): #{filter}"
-          ret = self.send(filter.intern)
-          @cancel_execution = true if ret == false 
+   filter_str = self.class.run_attr_method(chain_name.to_s)
+   return if filter_str.nil?
+
+   filters = []
+   filter_str.split(';').each do |f|
+        next if f.strip == ''
+        mp = f.split('|')
+        filters << [mp[0], mp[1]]
+   end
+
+   sorted_filters = filters.sort { |a,b| a[1] <=> b[1] }
+
+   sorted_filters.each do |f|
+     break if @cancel_execution
+     filter = f[0]
+     begin
+       if (!self.methods.include?(filter)) then
+           http_status "SERVER_ERROR"
+           raise ApplicationException.new("Filter not found in chain #{debug_filter_names}: #{filter}")
+       end
+       ret = self.send(filter.intern)
+       @cancel_execution = true if ret == false 
       rescue BreakControllerException => bc
         handle_exception(bc)
       end
@@ -204,6 +228,10 @@ class Controller < Widget
  public 
  def run_after_filters
    run_filters(:def_after_filter, 'After Filters')
+   ce = @cancel_execution
+   @cancel_execution = false
+   run_filters(:def_priority_after_filter, 'Priority After Filters')
+   @cancel_execution = ce
  end
 
 
@@ -235,13 +263,24 @@ class Controller < Widget
 
    if e.flags.has_key?(:error) then
      @_layout = false
+     http_status "SERVER_ERROR"
      clear
      @error_message = e.flags[:error]
      @cancel_execution = true
-     mab { html { body { h2 "Error"; text @error_message }}}
+     trace = ''
+     if Cuca::App.config['display_errors'] then
+       e.backtrace.each do |b|
+          trace<< "<br/>#{b}"
+       end
+     end
+     mab { html { body { h2 "Error"; text @error_message; br; text trace }}}
    end
  end
 
+ def action_name
+   $app.urlmap.action
+ end
+ 
  private
  # Overwrite this method to handle get and post events
  def run
@@ -261,7 +300,7 @@ class Controller < Widget
  # exceptions. what within [post,get,run]
  # TOTHINKABOUT: run before filter from this method?
  public
- def _do(what, subcall)	
+ def _do(what, subcall = nil)	
    return if @cancel_execution
    
    method_name = what
@@ -270,6 +309,8 @@ class Controller < Widget
       self.send(method_name) if self.methods.include?(method_name)
    rescue BreakControllerException => e
       handle_exception(e)
+   rescue ApplicationException => e
+      http_status "SERVER_ERROR"
    end
  end
 
@@ -301,6 +342,7 @@ class Controller < Widget
      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}")
      return nil
    end
  end
@@ -318,4 +360,3 @@ end
 
 
 end # Module
-

data/lib/cuca/layout.rb

@@ -47,6 +47,7 @@ class Layout < Widget
  # the controller will create the layout. The controller will also set the content_for_layout
  # assign besides other assigns from the controller.
  def initialize(params = {}, &block)
+   raise ArgumentError.new("Layout requires :assigns for layout content") if params[:assigns].nil?
    params[:assigns].each_pair do |k,v|
      instance_variable_set("@#{k.to_s}", v)
    end

data/lib/cuca/session.rb

@@ -71,6 +71,7 @@ module Cuca
 class Session
  attr_reader :flash
  attr_reader :page
+ attr_reader :cgi
 
  private
  def make_session
@@ -90,7 +91,7 @@ class Session
  # returns true/false if a session exists
  def exists?
    begin
-      p = @parameters.clone
+      p = @session_parameters.clone
       p['new_session'] = false
       session = CGI::Session.new(cgi, p)
    rescue ArgumentError
@@ -106,11 +107,13 @@ class Session
           'database_manager' => CGI::Session::PStore,
           'session_key' => App::config["session_key"],
           'session_path' => '/',
+#          'new_session' => false,
           'session_expires' => Time.now + App::config["session_valid"].to_i,
           'prefix' => App::config["session_prefix"] }
 
    make_session
 
+
    @flash = SessionFlash.new(self)
    @page  = SessionPage.new(self)
  end
@@ -143,14 +146,15 @@ class Controller
   # close it afterwards.
   def self.use_session
      priority_before_filter('ses_initialize_session')
-     after_filter('ses_close_session')
+     priority_after_filter('ses_close_session')
   end
 
   def ses_initialize_session
-    $session = Session.new($cgi)
+    $session = Session.new($app.cgi)
   end
   def ses_close_session
     $session.close
+#    $session = nil
   end
 end
 

data/lib/cuca/sessionpage.rb

@@ -18,6 +18,7 @@ class SessionPage
    @ses = session
    @ses[:SessionPage] ||= {}
    pagemem[pagekey] ||= {}
+   session.cgi.parameters.each_pair { |k,v|  self[k] = v } 
    expire
  end
 

data/lib/cuca/stdlib/arform.rb

@@ -1,4 +1,5 @@
 require 'cuca/stdlib/form'
+require 'cuca/stdlib/formerrors'
 require 'cuca/generator/markaby'
 
 # == Form's for ActiveRecord
@@ -42,13 +43,22 @@ class ARFormWidget < FormWidget
    @form_erros = {}
    p = request_parameters.dup
    p.delete(@submit_name)
+   
+   if @model.new_record? then 
+      @disabled_on_create.each { |d| p.delete(d) }
+      @hidden_on_create.each { |d| p.delete(d) }
+   else 
+      @disabled_on_update.each { |d| p.delete(d) }
+      @hidden_on_update.each { |d| p.delete(d) }
+   end
+
 
    # don't save empty passwords!!
    @password_fields ||= []
    @password_fields.each do |pwf|
       p.delete(pwf) if p[pwf].chomp.empty?
    end
-
+   $stderr.puts p.inspect
    @model.attributes = p
    
    return true if @model.valid?
@@ -187,6 +197,7 @@ end
    r << "<form action='#{@post_to}' method='POST'>\n"
    r << "<table>"
    @model.class.columns.each do |col|
+     next if field_hidden?(col.name)
      k = col.name
      v = @model.send(k.intern)		# this allows us to overwrite accessors
      r << "<tr><td>#{k}</td><td>#{fe(col.type,k,v)}</td></tr>"

data/lib/cuca/stdlib/listwidget/dblist.rb

@@ -78,9 +78,10 @@ class DBListWidget < BaseList
       ret
    end
    findstuff[:select] = sel.compact.join(',')
-#   $stderr.puts "Find-Stuff: #{findstuff.inspect}"
+   $stderr.puts "Find-Stuff: #{findstuff.inspect}"
    @data = @model_class.find(:all, findstuff)
    @data = normalize_result(@data)
+   
    @total_rows= @model_class.count(:conditions => where_clause(query_def), :joins => @joins)
    
 #   $stderr.puts "Query: #{@data.inspect} - #{query_def.order_by.inspect}"

data/lib/cuca/stdlib/listwidget/list.rb

@@ -154,6 +154,7 @@ end
                    %>
        </td>
       <% end %>
+      <td></td>
 
       <form name="<%=@list_name%>_form" method="POST">
       <tr>
@@ -163,11 +164,11 @@ end
               <% if c[:searchable] != false then %>
                 <input style='float:left;' type="text" name="<%=ftag%>" value="<%=@query_def.filters[c[:id]]%>" >
               <% end %>
-              <% if (@columns.last[:id] == c[:id]) then %>
-                   <input style='float:right;' type="submit" value="ok"> 
-             <% end %>
             </td>
-        <% end %>
+        <% end %>     
+
+        <td><input style='float:right;' type="submit" value="filter"></td>
+
       </tr>
       </form>
 

data/lib/cuca/test/helpers.rb

@@ -11,10 +11,12 @@ module Helpers
 # init the application. call this from the setup method.
 def init(app_path = '/', params = {})
  require 'cuca/cgi_emu'
- @app = Cuca::App.new(CGIEmu.new({'PATH_INFO' => app_path, 'QUERY_PARAMS' => params}))
+ @cgi = CGIEmu.new({'PATH_INFO' => app_path, 'QUERY_PARAMS' => params})
+ @app = Cuca::App.new(@cgi)
  @app.load_support_files
 end
 
+
 # this will create a widget instance with params and block
 # as passed to this function. Also it will pass current instance
 # variables to the assigns.

data/lib/cuca/urlmap-original.rb

@@ -0,0 +1,324 @@
+
+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')
+#                URLMap.new(base_path, url)
+#
+# You can then fetch the following values:
+#
+# * script 		- path to the controller file
+# * url			- unmodified URL as passed to initializer
+# * 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)
+# * base_url		- Base URL to the action (e.g.: /user/someone/show is -> /user/someone/)
+# * base_path		- Unmodified base_path
+# * action_path 	- Path to the action script
+# * action_path_full 	- Full path to action script
+# * path_tree		- an array of each directory on the way from /path/to/app to the script
+#                         (to look for include_directories in - see Cuca::Config)
+# * 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.base_url    => '/customer/__customer/'
+#  u.assigns 	 => { 'customer' => 'southwind_lda' }
+#  u.action_path => 'customer/southwind_lda/'
+#
+class URLMap
+ attr_reader :url		# current url
+ attr_reader :assigns
+ attr_reader :script
+ attr_reader :subcall
+ attr_reader :base_url
+ attr_reader :base_path
+ attr_reader :action
+ attr_reader :action_path
+ attr_reader :action_path_full
+ attr_reader :action_module
+ attr_reader :path_tree
+ 
+ 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
+
+
+ # scan_dir will look within a realdirectory for an unparsed url 'file' and return 
+ # it's real path
+ private
+ def scan_dir(base, file)
+
+   striped = "#{base}/#{file}"[@base_path.length..-1]
+   mount = Cuca::App.config['mount']  || {}
+   $stderr.puts "SCAN DIR: #{striped}"
+   $stderr.puts "MOUNTS:   #{mount.inspect}"
+   
+
+   if mount["#{striped}/"] then
+      $stderr.puts "Found mount point, returning: #{mount["#{striped}/"]}"
+      return mount["#{striped}/"]
+   end
+
+   if File.directory?("#{base}/#{file}") then
+     return file.empty? ? base : "#{base}/#{file}"		# avoid returning double //
+   end
+   
+   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
+   "#{base}/#{d[0]}"
+ end
+
+
+ private
+ def make_module(path)
+   const_name = "Appmod_#{path.gsub(/[\/\\]/, '_')}"
+   
+   if Cuca::Objects::const_defined?(const_name.intern) then
+     return Cuca::Objects::const_get(const_name.intern)
+   end
+ 
+   m = Module.new
+   Cuca::Objects::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
+
+   # files now contains something like:
+   # [users, show, martin, contacts]
+
+#   puts files.inspect  
+   real_path = @base_path.dup
+
+   # 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
+     @path_tree << r
+     real_path = r
+   end
+
+   @url               = @path_info
+   @base_url	      = "#{files[0..-2].join('/')}/"
+   @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)
+#   @path_tree	    = _tree(@base_path, @script)
+   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 = File.expand_path(base_path)
+   @script    = ''
+   @subcall   = nil
+   @default_actions = default_actions
+   @assigns = {}
+   @action = ''
+   @action_path = ''
+   @path_tree = [base_path]
+   scan
+   self
+ end
+
+end
+
+end
+
+
+#
+# Testings:
+#
+
+if __FILE__ == $0  then
+require 'app'
+ 
+ BASE = '/home/bones/src/cuca/app'
+ URL  = 'user/martin/somewhere/notexist/'
+ 
+ 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}"
+  puts "Path tree:        #{ds.path_tree.inspect}"
+  end
+  
+end
+
+
+
+
+
+
+
+# URL:             "/user/martin/show"
+# DIR:             "/user/__userid/show'
+# MOUNT:           "/user/__userid/" =>>> "/plugin/user"   contains 'show'
+# MOUNT:           "/user/__userid/" =>>> "/plugin/user2"  contains 'see'
+
+
+ 
+
+
+
+
+