RubyGems - cuca - Versions diffs - 0.01 - Mend

cuca 0.01

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

data/application_skeleton/README +21 -0
data/application_skeleton/app/_controllers/application.rb +7 -0
data/application_skeleton/app/_layouts/simple.rb +19 -0
data/application_skeleton/app/_widgets/sourcecode.rb +21 -0
data/application_skeleton/app/_widgets/test.rb +23 -0
data/application_skeleton/app/demo.rb +64 -0
data/application_skeleton/app/index.rb +39 -0
data/application_skeleton/app/user/__default_username/index.rb +7 -0
data/application_skeleton/conf/environment.rb +16 -0
data/application_skeleton/log/access.log +1 -0
data/application_skeleton/log/error.log +1 -0
data/application_skeleton/log/messages +1 -0
data/application_skeleton/public/css/style.css +27 -0
data/application_skeleton/public/dispatch.cgi +31 -0
data/application_skeleton/public/dispatch.fcgi +36 -0
data/application_skeleton/public/img/cuca-seagull.png +0 -0
data/application_skeleton/scripts/console +5 -0
data/application_skeleton/scripts/console.rb +5 -0
data/application_skeleton/scripts/server-lighttpd-fcgi.rb +116 -0
data/application_skeleton/scripts/server-lighttpd.rb +109 -0
data/application_skeleton/scripts/server-webrick.rb +26 -0
data/application_skeleton/scripts/test.rb +8 -0
data/application_skeleton/tests/widgets/link.rb +22 -0
data/bin/cuca +43 -0
data/lib/cuca/app.rb +317 -0
data/lib/cuca/cgi_emu.rb +67 -0
data/lib/cuca/cgi_fix.rb +58 -0
data/lib/cuca/const.rb +3 -0
data/lib/cuca/controller.rb +240 -0
data/lib/cuca/generator/markaby.rb +80 -0
data/lib/cuca/generator/view.rb +121 -0
data/lib/cuca/layout.rb +62 -0
data/lib/cuca/mimetypes.rb +89 -0
data/lib/cuca/session.rb +143 -0
data/lib/cuca/sessionflash.rb +56 -0
data/lib/cuca/sessionpage.rb +41 -0
data/lib/cuca/stdlib/arform.rb +208 -0
data/lib/cuca/stdlib/arview.rb +16 -0
data/lib/cuca/stdlib/form.rb +137 -0
data/lib/cuca/stdlib/formerrors.rb +20 -0
data/lib/cuca/stdlib/link.rb +37 -0
data/lib/cuca/stdlib/list.rb +3 -0
data/lib/cuca/stdlib/listwidget/dblist.rb +122 -0
data/lib/cuca/stdlib/listwidget/list.rb +189 -0
data/lib/cuca/stdlib/listwidget/querydef.rb +167 -0
data/lib/cuca/stdlib/listwidget/staticdatalist.rb +79 -0
data/lib/cuca/stdlib/slink.rb +30 -0
data/lib/cuca/test/helpers.rb +42 -0
data/lib/cuca/urlmap.rb +267 -0
data/lib/cuca/widget.rb +212 -0
data/lib/cuca.rb +68 -0
metadata +141 -0

data/lib/cuca/generator/markaby.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require 'markaby'
+# Modify Markaby's method_missing function so we find our own widgets
+#
+class ::Markaby::Builder		# :nodoc:
+  alias :old_method_missing :method_missing
+  def method_missing(sym, *args, &block )	# :nodoc:
+    class_name = sym.id2name
+    begin
+      c=Object::const_get(class_name+"Widget")
+    rescue NameError => e
+      return old_method_missing(sym,*args,&block)
+    end
+#    $stderr.puts "Widget in markaby: Class: #{class_name}, \n\n assigns: #{@assigns.inspect} \n\n"
+    widget = c.new({:args => args,
+                    :assigns => @assigns },
+                    &block)
+ #   $stderr.puts "Widget:" + widget.inspect
+    @builder <<  widget.to_s
+#    $stderr.puts "Good"
+  end
+end
+module Cuca
+# == Generator
+# A generator is a mixin to Cuca::Widget. It should provide functions that generate
+# content.
+# Visible within a generator function should be all instance variables, all instance
+# methods and an easy accessor to widgets. For example the view and markaby generators
+# that come with cuca you can call a widget like:
+#   Link(a,b,c..) { block}
+# and it will initialize the LinkWidget
+module Generator
+# == Markaby Generator
+#
+# Markaby Generator provides the mab and mabtext functions to generate content.
+#
+# Usage example within a controller:
+#
+#  require 'cuca/generator/markaby'
+#  class IndexController < ApplicationController
+#   include Cuca::Generator::Markaby
+#   def run
+#     mab { Link('/to/somewhere') { b { "Click" }}}
+#   end
+#  end
+#
+# The above will make use of widget 'LinkWidget' (must be defined)
+#
+# For more information of Markaby pls see the markaby website.
+#
+# === Performance Warning
+#
+# Unfortunately Markaby is not famous to be fast. Using it on recuring widgets
+# can significantly slow down your application.
+#
+#
+module Markaby
+   # use this to add markaby code to @content
+  def mab(&block)
+    @_content << ::Markaby::Builder.new(get_assigns, self, &block).to_s
+  end
+  # Use this to generate html code with a markaby block and have it as a string
+  def mabtext(&block)
+    ::Markaby::Builder.new(get_assigns, self, &block).to_s
+  end
+end
+end # Module Generator
+end # Module Cuca

data/lib/cuca/generator/view.rb ADDED Viewed

@@ -0,0 +1,121 @@
+require 'erb'
+module Cuca
+module Generator
+# == View Generator
+#
+# The view generator allows you to define content using an ERB template - similar to
+# Ruby on Rails.
+#
+# Example use within a Controller:
+#
+#  require 'cuca/generator/view'
+#  class IndexController
+#    include Cuca::Generator::View
+#
+#    def run
+#      @some_variable = "Stuff"
+#      @page_title = "Hello World"
+#      view('template.rhtml')
+#    end
+#  end
+#
+# And the template (template.rhtml)
+#
+#  <html>
+#   <head>
+#    <title><%= @page_title %></title>
+#   </head>
+#   <body>
+#     <% (1..10).each do |idx|  %>  <!-- Embedded Ruby Code ->
+#       <%= idx.to_s %> - <b>Some variable: <%= @stuff %></b><br/>
+#     <% end %>
+#     An external Widget: <%= Link('/to/somewhere') { b { "Click me" }} %>
+#   </body>
+#  </html>
+#
+# For more information about ERB templates visit it's website.
+#
+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
+      begin
+         # 1st try to find method in the base widget
+         if @base.methods.include?(class_name) then
+             return @base.send(class_name, *args, &block)
+         end
+         # 2nd try to find a widget
+         c=Object::const_get(class_name+"Widget")
+      rescue NameError => e
+         raise "Undefined method: #{sym.id2name}"
+      end
+      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.
+  # This will return the generated markup as a string
+  def viewtext(filename=nil)
+    view_dir = $cuca_path + '/' + App::config['view_directory']
+    begin
+       f = File.open(VIEW_DIR + "/#{filename}", 'r')
+    rescue => e
+       return "Error opening template: #{e}"
+    end
+    template = f.read
+    f.close
+    viewtext_p(template)
+  end
+  # Procuce content and append to widget.
+  def view(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)
+  end
+  # Equivaltent to view but take template as a string.
+  def view_p(template)
+    @_content << viewtext_p(template)
+  end
+end
+end # Mod: Generator
+end # Mod: Cuca

data/lib/cuca/layout.rb ADDED Viewed

@@ -0,0 +1,62 @@
+module Cuca
+# === Layout
+# A Layout just behaves as a normal widget plus it will give you the @content_for_layout
+# instance variable with the content generated from the controller.
+#
+# == Naming
+# Name it FilenameLayout (ending always with Layout, for example: 'StandardLayout' or 'FancyLayout').
+# When you specify your layout in the controller simply do a
+#  layout 'standard'
+#
+# == Examples
+# Layout Class:
+#
+#  class PlainLayout < Cuca::Layout
+#
+#   def output
+#     content << <<-EOI
+#       <html>
+#         <head><title>#{@page_title}</title></head>
+#       <body>
+#        #{@content_for_layout}
+#       <hr>
+#       <small>Rendered using the Plain Layout - at #{Time.new.to_s}</small>
+#       </body>
+#       </html>
+#       EOI
+#   end
+#  end
+#
+#
+# Example Controller that would work with the above layout:
+#
+#  class IndexController < Cuca::Controller
+#   layout 'plain'
+#
+#   def run
+#      @page_title = "Main Page"
+#      content << "<h3>Welcome to my Webpage</h3>
+#   end
+#  end
+#
+# Note: The above example doesn't make use of a generator - which would simplify the development of
+# larger layouts and controllers.
+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)
+   params[:assigns].each_pair do |k,v|
+     instance_variable_set("@#{k.to_s}", v)
+   end
+   super
+ end
+ def to_s
+    output
+    return content.to_s
+ end
+end
+end

data/lib/cuca/mimetypes.rb ADDED Viewed

@@ -0,0 +1,89 @@
+module Cuca
+#
+# MimeTypes is a self-writing hash.
+# Will take the data of the mime.types file
+# key is the file extension.
+#
+# MimeTypes.new['avi'] = > video/x-msvideo
+#class MimeTypes < Hash
+#
+# def initialize(fn = '/etc/mime.types')
+#
+#    f = File.new(fn, 'r') or throw StandardError("Can't open #{fn}")
+#    while (line = f.readline) do
+#      line = line.chomp
+#      next if line.length == 0
+#      next if line[0] == '#'[0]
+#      ls = line.scan(/[a-zA-Z\-\/0-9]+/)
+#      next if line.size == 0
+#      ls[1..-1].each { |e| self[e] = ls[0] }
+#    end
+#    f.close
+#
+#    rescue EOFError
+#       f.close
+# end
+# end
+class MimeTypes < Hash # :nodoc:
+ def initialize
+ super
+ {"rpm" => "application/x-rpm",
+  "pdf" => "application/pdf",
+  "sig" => "application/pgp-signature",
+  "spl" => "application/futuresplash",
+  "class" => "application/octet-stream",
+  "ps" => "application/postscript",
+  "torrent" => "application/x-bittorrent",
+  "dvi" => "application/x-dvi",
+  "gz" => "application/x-gzip",
+  "pac" => "application/x-ns-proxy-autoconfig",
+  "swf" => "application/x-shockwave-flash",
+  "tar.gz" => "application/x-tgz",
+  "tgz" => "application/x-tgz",
+  "tar" => "application/x-tar",
+  "zip" => "application/zip",
+  "mp3" => "audio/mpeg",
+  "m3u" => "audio/x-mpegurl",
+  "wma" => "audio/x-ms-wma",
+  "wax" => "audio/x-ms-wax",
+  "ogg" => "audio/x-wav",
+  "wav" => "audio/x-wav",
+  "gif" => "image/gif",
+  "jpg" => "image/jpeg",
+  "jpeg" => "image/jpeg",
+  "png" => "image/png",
+  "xbm" => "image/x-xbitmap",
+  "xpm" => "image/x-xpixmap",
+  "xwd" => "image/x-xwindowdump",
+  "css" => "text/css",
+  "html" => "text/html",
+  "htm" => "text/html",
+  "js" => "text/javascript",
+  "asc" => "text/plain",
+  "c" => "text/plain",
+  "conf" => "text/plain",
+  "text" => "text/plain",
+  "txt" => "text/plain",
+  "dtd" => "text/xml",
+  "xml" => "text/xml",
+  "mpeg" => "video/mpeg",
+  "mpg" => "video/mpeg",
+  "mov" => "video/quicktime",
+  "qt" => "video/quicktime",
+  "avi" => "video/x-msvideo",
+  "asf" => "video/x-ms-asf",
+  "asx" => "video/x-ms-asf",
+  "wmv" => "video/x-ms-wmv",
+  "bz2" => "application/x-bzip",
+  "tbz" => "application/x-bzip-compressed-tar",
+  "tar.bz2" => "application/x-bzip-compressed-tar"}.each_pair { |k,v| self[k] = v }
+ end
+end
+end
+# puts Cuca::MimeTypes.new['avi']

data/lib/cuca/session.rb ADDED Viewed

@@ -0,0 +1,143 @@
+require 'cgi/session'
+require 'cgi/session/pstore'
+require 'cuca/app'
+require 'cuca/widget'
+require 'cuca/sessionflash'
+require 'cuca/sessionpage'
+module Cuca
+# == Description
+# Session can be used to store stateful data. It is not loaded by default, to make
+# use of it you must require this module and tell a controller to use a session.
+#
+# == Example Use (permanent data)
+#
+# Initialize (using a controller):
+#
+#  class ApplicationController < Cuca::Controller
+#    use_session
+#  end
+#
+# Save and Load data (from any widgets e.g. controller):
+#
+#  class IndexController < ApplicationController
+#
+#    def run
+#       session[:stuff_to_remember] = "hello world"
+#       @stuff = session[:stuff_to_remember]
+#    end
+# end
+#
+# == Flash Memory
+#
+# The flash memory can be used to store temporarily data for the current and
+# next action. A typical example are messages after a post event, like:
+#
+#  class LoginController < ApplicationController
+#      (...)
+#     def post
+#         if (params['username'] == 'root' && params['pass'] == 'stuff') then
+#            session.flash[:message] = "You are logged in"
+#            session[:username] = 'root'
+#            stop :redirect => 'index'
+#         end
+#     end
+#  end
+#
+# If you want to keep the flash memory for another cycle you can call:
+#
+#  session.flash.keep
+#
+#
+# == Page Memory
+#
+# Page memory is a container to store data only valid for the current action.
+# It will be erased once you leave to a different action.
+#
+#
+#
+# == Configuration
+#
+# Session is using some values from App::Config :
+#
+# 'session_prefix'
+# 'session_valid'
+# 'session_key'
+#
+class Session
+ attr_reader :flash
+ attr_reader :page
+ private
+ def make_session
+   @sess = CGI::Session.new(@cgi, @session_parameters)
+ end
+ public
+ def reset
+   begin
+     @sess.delete
+   rescue
+   end
+   make_session
+ end
+ # returns true/false if a session exists
+ def exists?
+   begin
+      p = @parameters.clone
+      p['new_session'] = false
+      session = CGI::Session.new(cgi, p)
+   rescue ArgumentError
+      return false
+   end
+   return true
+ end
+ def initialize(cgi)
+   @cgi = cgi
+   @session_parameters = {
+          'database_manager' => CGI::Session::PStore,
+          'session_key' => App::config["session_key"],
+          'session_path' => '/',
+          '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
+ def []=(key, value)
+   @sess[key] = value
+ end
+ def [](key)
+   return @sess[key]
+ end
+ def close
+   @sess.close
+ end
+end
+class Widget
+  def self.use_session
+     @@session ||= Session.new($cgi)
+  end
+  def session
+     @@session
+  end
+end
+end

data/lib/cuca/sessionflash.rb ADDED Viewed

@@ -0,0 +1,56 @@
+module Cuca
+# Whatever you write into flash will be valid for the current and for the
+# next action. You can keep the content for another cycle by calling the
+# keep method. Access via session.flash. (See Cuca::Session)
+class SessionFlash
+ class SessionFlashItem # :nodoc:
+    def value
+        @value
+    end
+    def initialize(val)
+        @value = val
+        @cyc  = 0
+    end
+    def inc
+       @cyc+=1
+    end
+    def expired?
+       @cyc > 1
+    end
+    def keep
+      @cyc=@cyc-1
+    end
+ end
+ private
+ def flashmem
+   @ses[:SessionFlash]
+ end
+ public
+ def initialize(session)
+    @ses = session
+    @ses[:SessionFlash] ||= {}
+    expire
+ end
+ def [](key)
+    flashmem[key] ? flashmem[key].value : nil
+ end
+ def []=(key, value)
+    flashmem[key] = SessionFlashItem.new(value)
+ end
+ def keep
+    flashmem.each_pair { |k,v| v.keep }
+ end
+ private
+ def expire
+   flashmem.each_pair { |k,v| v.inc; flashmem.delete(k) if v.expired? }
+ end
+end
+end

data/lib/cuca/sessionpage.rb ADDED Viewed

@@ -0,0 +1,41 @@
+module Cuca
+# A session page (access via session.page) is memory that is only valid
+# for the current action. Once you leave to another page it will
+# be erased. (see Cuca::Session)
+class SessionPage
+ private
+ def pagekey
+   "Pk_#{$app.urlmap.script.gsub(/[\/\\]/, '_')}".intern
+ end
+ def pagemem
+   @ses[:SessionPage]
+ end
+ public
+ def initialize(session)
+   @ses = session
+   @ses[:SessionPage] ||= {}
+   pagemem[pagekey] ||= {}
+   expire
+ end
+ def [](key)
+    pagemem[pagekey][key] ? pagemem[pagekey][key] : nil
+ end
+ def []=(key,value)
+    pagemem[pagekey][key] = value
+ end
+ private
+ def expire
+    pagemem.each_pair do |k,v|
+      pagemem.delete(k) if k != pagekey
+    end
+ end
+end
+end