cuca 0.01

data/lib/cuca/stdlib/arform.rb

@@ -0,0 +1,208 @@
+module Cuca::Stdlib
+
+require 'form'
+require 'cuca/generator/markaby'
+
+# == Form's for ActiveRecord
+# AR Form can work just by providing one model of ActiveRecord.
+# Likly that you want to overwrite the form method to
+# run a custom layout. You can use the fe* methods to
+# build form elements for the model columns
+#
+# = Example:
+#
+#  ARForm('user_edit', User.find_by_username('bones'), 
+#                     :disable_on_update => ['username', 'created'])
+#
+class ARFormWidget < FormWidget
+
+ include Cuca::Generator::Markaby
+
+ # valid options
+ # * :disabled_on_create => ['field_name_1', 'field_name_2', ..]
+ #     switch off fields on new records
+ # * :diabled_on_update =>  ['field_name_1', 'field_name_2', ..]
+ #     switch off fields on existing records
+ def output(form_name, model, options = {})
+   @model = model
+   @disabled_on_update = options[:disabled_on_update] || []
+   @disabled_on_create = options[:disabled_on_create] || []
+   @hidden_on_update     = options[:hidden_on_update] || []
+   @hidden_on_create     = options[:hidden_on_create] || []
+   super(form_name, options[:post_to])
+ end
+
+ def on_submit
+  controller.send(@form_name+'_submit', @model) unless controller.nil?
+ end
+
+ def validate
+   form	if @_content.empty? # password fields might write hints to the validator...
+   @form_erros = {}
+   p = request_parameters.dup
+   p.delete(@submit_name)
+
+   # don't save empty passwords!!
+    $stderr.puts "Before validate: #{@password_fields.inspect}"
+   @password_fields ||= []
+   @password_fields.each do |pwf|
+     $stderr.puts "PWS: #{pwf} - #{p[pwf]}"
+      p.delete(pwf) if p[pwf].chomp.empty?
+     $stderr.puts "PWS: #{p.inspect}"
+   end
+
+   $stderr.puts "ARFORM Validate #{p.inspect}"
+   @model.attributes = p
+   
+   return true if @model.valid?
+
+   @model.errors.each do |k,v|
+      @form_errors[k] = v
+   end
+ end
+
+ # to make a 2 digit string out a number
+ private
+ def twodig(n)
+   n.to_s.length == 1 ? "0"+n.to_s : n.to_s
+ end
+
+ def field_enable?(fname)
+   if @model.new_record? then
+      return @disabled_on_create.include?(fname) ? false : true
+   else
+      return @disabled_on_update.include?(fname) ? false : true
+   end
+ end
+ def field_hidden?(fname)
+   if @model.new_record? then
+      return @hidden_on_create.include?(fname) ? true : false
+   else
+      return @hidden_on_update.include?(fname) ? true : false
+   end
+ end
+
+
+ private 
+ def fe_text(name, value,enabled)
+   "<input type='text' name='#{name}' value='#{value}' #{'disabled' unless enabled}>"
+ end
+
+ # the fe-password is special: will never contain a value and will not save the
+ # password if nothing was typed into the field
+ private
+ def fe_password(name,enabled)
+   @password_fields ||= []
+   @password_fields << name
+   r = "<input type='password' name='#{name}' #{'disabled' unless enabled}>"
+   if !@model.new_record? then
+     r << "<br><small>Leave empty to keep current password</small>"
+   end
+   return r
+ end
+
+ # this is to build a select box, example:
+ # fe_select('gender', [['f', 'female'],['m','Male']], true) or
+ # fe_select('gender', ['f','m'], true)
+ private
+ def fe_select(name, options, enabled)
+   r = "<select name='#{name}' #{'disabled' unless enabled}>\n"
+   options.each do |o|
+     ov = o.instance_of?(Array) ? o[0] : o
+     sel = ''
+     sel = ' selected' if @model.send(name.intern) == ov
+     if o.instance_of?(Array) then
+       r+="<option value='#{o[0]}'#{sel}>#{o[1]}</option>\n"
+     else
+      r+="<option value='#{o}'#{sel}>#{o}</option>\n"
+     end
+   end
+   r+="</option>\n" 
+end
+
+
+ def fe_datetime(name, v,enabled)
+   v = Time.now unless v
+   r = <<-EOS
+<input type='text' name='#{name}' id='i_#{name}' value='#{v.year}/#{twodig(v.month)}/#{twodig(v.day)} #{v.hour}:#{v.min}' #{'disabled' unless enabled}>
+  EOS
+    if enabled then 
+      r << <<-EOS 
+<input type='submit' id='s_#{name}' value='...'>
+<script type="text/javascript">
+    Calendar.setup({
+        inputField     :    "i_#{name}",      // id of the input field
+        ifFormat       :    "%Y/%m/%d %H:%M",       // format of the input field
+        showsTime      :    true,            // will display a time selector
+        button         :    "s_#{name}",   // trigger for the calendar (button ID)
+        singleClick    :    true,           // double-click mode
+        step           :    1                // show all years in drop-down boxes (instead of every other year as default)
+     }); 
+</script>
+</input>
+     EOS
+   end
+   return r
+ end
+
+ def fe_bool(name,v,enabled)
+    r = ''
+    r << "<select name='#{name}' #{'disabled' unless enabled}>\n"
+    r << "<option #{"selected" if v} value='t'>true</option>\n"
+    r << "<option #{"selected" if !v} value='f'>false</option>\n"
+    r << "</select>\n"
+ end
+
+ def fe_int(name,v,enabled)
+   "<input type='text' name='#{name}' value='#{v}' #{'disabled' unless enabled} size=5>"
+ end
+
+ def fe(type, name, value='')
+   return '' if field_hidden?(name)
+   enabled = field_enable?(name)
+   r = ""
+   case(type)
+       when :string
+          r << fe_text(name,value,enabled)
+       when :boolean
+          r << fe_bool(name,value,enabled)
+       when :integer
+         r << fe_int(name,value,enabled)
+       when :datetime
+         r << fe_datetime(name,value,enabled)
+       when :password
+         r << fe_password(name, enabled)
+     end
+   return r
+ end
+
+ # build a form element for column name
+ def fe_for(column_name, hint='')
+   col = @model.column_for_attribute(column_name)
+   fe(col.type, col.name, @model.send(column_name.intern))
+ end
+
+
+ # you might want to replace this method
+ public
+ def form
+   r = mabtext { FormErrors(@form_errors) }
+   r << "<form action='#{@post_to}' method='POST'>\n"
+   r << "<table>"
+   @model.class.columns.each do |col|
+     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>"
+   end
+   r << "<tr><td><br/></td></tr>"
+   r << "<tr><td></td><td><input type='submit' value=#{@model.new_record? ? 'Save' : 'Update'} name='#{@submit_name}'></td></tr>"
+   r << "</table>\n</form>\n"
+   @_content = r
+ end
+
+
+end
+
+
+
+end

data/lib/cuca/stdlib/arview.rb

@@ -0,0 +1,16 @@
+
+# This is a small widget to display an ActiveRecord Record
+class ARViewWidget < Cuca::Widget
+
+ def output(model, headline='')
+  @model = model
+
+   r = "<table>"
+   @model.class.columns.each do |col|
+     r << "<tr><td>#{col.name}</td><td>#{@model.send(col.name.intern)}</td></tr>"
+   end
+   r << "</table>"
+   @_content = r
+ end
+
+end

data/lib/cuca/stdlib/form.rb

@@ -0,0 +1,137 @@
+#
+# == Cuca Standard Widget Library
+# This namespace should contain a standard widget library.
+# 
+# <b>Warning: The widgets you find here are fairly untested and might not work!!</b>
+# Any request and patches - Welcome
+# module Cuca::Stdlib
+
+# == FormWidget
+#
+# To implement a form inherit this class and overwrite:
+#
+# * form - generate your form (as if it was the output method of a widget)
+#   - Use @form_name for your html form name
+#   - Use @submit_name for your submit button
+# * validate - to validate a posted form
+#   - write @form_errors['element_name'] on errors (to handle them with FormErrors Widget)
+# * setup - Define initial values for your form
+#
+# A form will call {form_name}_submit(result) on the CONTROLLER if the form was submitted
+# and validation passed.
+# If you don't want this, overwrite on_submit
+#
+# A form will use instance variables for form values
+class FormWidget < Cuca::Widget
+
+ def posted?
+   return (request_method == 'POST' && !params[@submit_name].nil?)
+ end
+ 
+ # get from params and set instance variables
+ def load_variables
+   $stderr.puts "\n\nLoad Variables: #{$cgi.params.inspect}\n\n"
+   params.each_pair { |k,v| instance_variable_set('@'+k, v) ; $stderr.puts "Form: Setting #{k} - #{v}" }
+ end
+
+ # get from params and return them as hash
+ def get_variables
+   r = {}
+   params.each_pair { |k,v| r[k] = v }
+   return r
+ end
+
+ # Overwrite this method to setup initial values
+ # This method will not be called if the form get submitted.
+ def setup
+ end
+
+
+ # Create your form by overwriting this demo
+ # Name your submit button @submit_name, so the form can detect if it
+ # is submitted or not.
+ def form
+ end
+ 
+ # Overwrite this method with your validation code
+ # @form_errors hash with error messages
+ def validate
+ end
+
+ # If form is validated we call on_submit. Default behaviour is to call
+ # {form_name}_submit(result) on the CONTROLLER.
+ def on_submit
+  controller.send(@form_name+'_submit', get_variables) unless controller.nil?
+ end
+
+ def output(form_name, post_to = nil)
+   @form_name = form_name
+   @post_to   = post_to || cgi.path_info
+   @submit_name = 'submit_'+@form_name
+   @form_errors = {}
+
+   if posted? then
+     load_variables
+     validate
+     if @form_errors.empty? then
+        clear		# submitted forms should not have any content that might have been generated
+        return on_submit
+     else
+        form
+     end
+   else
+     setup
+     form
+   end
+ end
+end
+
+
+
+require 'cuca/generator/markaby'
+
+class TestFormWidget < FormWidget
+
+ include Cuca::Generator::Markaby
+
+ def setup
+   @demo_input = "enter something"
+ end
+
+ def make_tips
+   @form_errors.each_pair do |k,v| 
+      hints[:tips] ||= []
+      hints[:tips] << { :id => k, :title => "Error in form", :text => v}
+  end
+ end
+
+
+ def validate
+   # validate form return true/false
+   if @demo_input != 'demo' then
+     @form_errors['demo_input'] = "I said please enter 'demo' but you entered #{@demo_input}"
+   end
+   make_tips
+   true
+ end
+
+ def form
+   mab { 
+
+      FormErrors(@form_errors)
+ 
+       form( :action=>@post_to, :method=>'post') { # :name=>@form_name,
+	 text "This is a demo form, overwrite 'form' method. Enter 'demo'"
+         br
+	 E('demo_input', true) { input(:type => 'text', :value => @demo_input, :name=>'demo_input'); text @error_text }
+         br
+         br
+         input(:type => 'submit', :value => 'save', :name => @submit_name)
+        }
+   }
+ end
+
+end
+
+
+# end

data/lib/cuca/stdlib/formerrors.rb

@@ -0,0 +1,20 @@
+require 'cuca/generator/markaby'
+
+# this widget you can use within a form to display all form errors
+class FormErrorsWidget < Cuca::Widget
+ 
+ include Cuca::Generator::Markaby
+ 
+ def output(form_errors, title = nil)
+   return if form_errors.empty?
+   mab {
+     b title ? title : "Form contains errors"
+     ul {
+      form_errors.each_pair { |name, value| 
+         li { b {name}; text " - #{value}" }
+      }
+     }
+   }
+ end
+
+end

data/lib/cuca/stdlib/link.rb

@@ -0,0 +1,37 @@
+require 'cuca/generator/markaby'
+
+
+# A markaby link - Please use with care!! it's slow! Better to use SLinkWidget.
+class LinkWidget < Cuca::Widget
+
+ include Cuca::Generator::Markaby
+
+ private
+ def build_href(target, params)
+    r = target
+   
+    r=r+"?" unless params.empty?
+
+    params.each_key do |key|
+     r = r + '&' unless r[r.size-1].chr == '?'
+     r = "#{r}#{key}=#{params[key]}"
+    end
+    return r
+ end
+
+# public
+# def output(target, params = {}, tag_attrib = {}, &block)
+#
+# end
+
+
+ public
+ def output(target, params = {}, tag_attrib = {}, &block) 
+   @attribs = tag_attrib
+   @attribs[:href] = build_href(target, params) 
+   @block = block
+   mab {
+        a(@attribs)  { text capture(&block) }
+   }
+ end
+end

data/lib/cuca/stdlib/list.rb

@@ -0,0 +1,3 @@
+require 'cuca/stdlib/listwidget/list'
+require 'cuca/stdlib/listwidget/dblist'
+require 'cuca/stdlib/listwidget/staticdatalist'

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

@@ -0,0 +1,122 @@
+require 'cuca/stdlib/listwidget/list'
+require 'active_record'
+
+# List with Active Record model as data source
+#
+# DBList('dblistname', User, :columns => [ { :id => 'id', :query => 'user.id', :display=>'ID' },
+#                                          { :id => 'name',  :display=>'Name', :searchable=>false } ])
+#
+# Options:
+# :joins => ActiveRecord find :joins options.
+#
+# :columns: Columns possible flags:
+#   :id         => [required] name. Likly this is the database column name
+#   :query      => [optional] how to query the id (eg: users.name) . If false then treated as virtual column
+#   :display    => [optional] title for the column
+#   :searchable => [optional] true/false if this column can be searched (default autodetect)
+#   :sortable = => [optional] true/false if columns can be sorted (default autodetect)
+# DBLIST specific is only :query
+class DBListWidget < BaseList
+ def columns
+#   $stderr.puts " Getting Columns: #{@columns}"
+   @columns
+ end
+  
+ # returns :query field by :id (only :id is defined in the QueryDef)
+ def wc_query_field(field_id)
+    @columns.each do |c| 
+          if c[:id] == field_id then 
+             return c[:query]
+          end
+    end
+    field_id
+ end
+
+ def where_clause(query_def)
+   res = []
+   query_def.filters.each_pair do |k,v|
+       next if (v.nil? || v == '')
+       if @model_class.columns_hash.include?(k) && @model_class.columns_hash[k].number? then
+         res << "#{wc_query_field(k)} = #{v}"
+       else
+         res << "#{wc_query_field(k)} LIKE '%#{v}%'"
+       end
+   end
+   wc =  "true"
+   res.collect { |e| "(#{e})" }.each { |c| wc+=" AND #{c}" }
+   wc+= " AND #{@extra_conditions}" if @extra_conditions != ''
+#   $stderr.puts "WHERE clause is #{wc}"
+   return wc
+ end
+
+ # transform a active record result to an [[]]- array
+ def normalize_result(ar_res)
+   res = []
+   ar_res.each do |r|
+      c = []
+      columns.each do |col| 
+			# fixme: this doesn't catch join table results!!!
+         if @model_class.column_methods_hash[col[:id].intern] then
+            c << r.send(col[:id].to_sym)
+         else
+            c << ''
+         end
+      end
+      res << c
+   end
+   res
+ end
+
+ def query(query_def)
+   findstuff = {:conditions => where_clause(query_def) }
+   findstuff[:order]  = query_def.order_by unless (query_def.order_by.nil? || query_def.order_by == '')
+   findstuff[:offset] = query_def.range.first
+   findstuff[:limit]  = query_def.range.last-query_def.range.first+1
+   findstuff[:joins]  = @joins || nil
+   sel = @columns.collect do |c| 
+      ret = c.has_key?(:query) ? "#{c[:query]} as #{c[:id]}" : c[:id] 
+      ret = nil if c[:query] == false
+      ret
+   end
+   findstuff[:select] = sel.compact.join(',')
+#   $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}"
+ end
+
+ def setup
+   super
+ end
+
+
+ # this will fix/add searchable/sortable and query flag
+ def fixup_columns
+    @columns.each_index do |idx| 
+
+      if @columns[idx][:searchable].nil? then
+          @columns[idx][:searchable] = @model_class.column_methods_hash[@columns[idx][:id].intern] ? true : false
+      end
+      @columns[idx][:query] = @columns[idx][:id] if @columns[idx][:query].nil?
+      
+      if @columns[idx][:sortable].nil? then
+          @columns[idx][:sortable] = @columns[idx][:query] == false ? false : true
+      end
+      
+    end
+ end
+
+ def output(list_name, model_class = nil, data_setup = {})
+   @columns           = data_setup[:columns] || [] 
+   @extra_conditions = data_setup[:conditons] || ""
+   @joins	      = data_setup[:joins] || ""
+   @model_class = model_class || nil
+   setup
+   fixup_columns
+#   $stderr.puts @columns.inspect
+   @columns.freeze
+   @extra_conditions.freeze
+   super(list_name)
+ end
+end