cuca 0.01

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

@@ -0,0 +1,189 @@
+
+require 'cuca/generator/view'
+require 'cuca/generator/markaby'
+require 'cuca/stdlib/listwidget/querydef'
+require 'cuca/stdlib/slink'
+
+# this is the parent class for dblist and staticdatalist
+class BaseList < Cuca::Widget
+ include Cuca::Generator::View
+ include Cuca::Generator::Markaby
+  
+ attr_reader :data
+ attr_reader :rewrite_hooks
+
+
+ # Add a proc to rewrite content of a field
+ # proc must take two arguments, |row_content, field_content|
+ def add_rewrite_hook(field_id, &proc)
+    @rewrite_hooks||= {}
+    @rewrite_hooks[field_id] = proc
+ end
+
+ def rewrite_field(row, field_id, content)
+#   $stderr.puts "REwrite field(#{row.inspect}, #{field_id.inspect}, #{content.inspect} - hooks #{@rewrite_hooks.inspect}"
+   return content unless @rewrite_hooks[field_id]
+   return @rewrite_hooks[field_id].call(row, content)
+ end
+
+
+ # Use to initialize 
+ #
+ def setup
+ end
+
+ # OVERWRITE
+ # return a list of columns
+ def columns
+   return [{:id=>"one", :display =>'One', :searchable=>false}, {:id=>'two', :display => 'three'}]
+ end
+
+ #OVERWRITE:
+ # fetch data and write:
+ # @data       = [['a','b', 12], ...]
+ # @total_rows = 123
+ def query(query_definition)
+   return 
+ end
+
+ # TODO: Load from Session
+ def load_query_definition
+   qd = QueryDef.new(@list_name)
+   qd.from_params(params)
+ end
+
+ def output(list_name)
+   @list_name = list_name
+
+   @columns = columns
+   @query_def = load_query_definition
+   query(@query_def)
+   @paginate = paginate_links()
+   @params = params
+   @rewrite_hooks ||= {}
+
+   callback_method = "#{@list_name}_data"
+
+#   $stderr.puts "Callback check: #{controller.nil?.inspect}  \n\n -- #{controller.methods.sort.inspect} --\n\n NAME #{controller.class.inspect}"
+   if !controller.nil? && controller.methods.include?(callback_method) 
+      controller.send(callback_method, @data)
+   end
+
+   view_p(erb_template)
+ end # def
+
+ private
+ def paginate_links()
+   @rows_per_page = (@query_def.range.last - @query_def.range.first) + 1
+   @total_pages = (@total_rows / @rows_per_page).to_i
+   @total_pages = @total_pages + 1 unless ((@total_rows % @rows_per_page) == 0)
+ 
+   pl = '' ; i = 0
+   (0..(@total_pages-1)).each do |p|
+      range = i..(i+@rows_per_page-1)
+      if range.include?(@query_def.range.first+1) then
+          pl<< "#{(p+1).to_s} "
+      else
+          pl << "#{SLinkWidget.new(:args=>['',(p+1).to_s,@query_def.to_h('range', range)]).to_s} "
+      end
+      i+=@rows_per_page
+  end
+   
+  return pl
+
+#### The above should be a bit faster that this mab version:
+# return mabtext do
+#  i = 0
+#     (0..(@total_pages-1)).each do |p|
+#      range = i..(i+@rows_per_page-1)
+#         $stderr.puts "#{range.inspect} include? #{@query_def.range.first+1}"
+#       if range.include?(@query_def.range.first+1) then
+#       text((p+1).to_s + " ")
+#      else
+#           Link('', @query_def.to_h('range', range)) { ((p+1).to_s) }
+#           SLink('',(p+1).to_s, @query_def.to_h('range', range))
+#          text " "
+#         end
+#         i+=@rows_per_page
+#      end
+#  end
+end
+ 
+ private
+ def erb_template
+  <<'ENDTEMPLATE'
+ <div class='list'>
+ <%= @paginate %>
+ <table width>
+    <tr>
+
+      <% @columns.each do |c| %>
+        <td class='hl'>
+           <%= (@query_def.order_by == c[:id] || (c[:sortable] == false)) ?
+                  c[:display] : SLink('',c[:display],@query_def.to_h('order_by', c[:id]))
+                   %>
+       </td>
+      <% end %>
+
+      <form name="<%=@list_name%>_form" method="POST">
+      <tr>
+        <% @columns.each do |c|
+           ftag = "#{@list_name}_filter_#{c[:id]}" %>
+            <td>
+              <% 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 %>
+      </tr>
+      </form>
+
+      <% @data.each do |row| %>
+      <tr>
+           <% row.each_index do |field_idx| %>
+              <td> <%= rewrite_field(row, @columns[field_idx][:id], row[field_idx]) %> </td>
+           <% end %>
+      </tr>
+      <% end %>
+  </table>
+</div>
+ENDTEMPLATE
+ end
+ 
+end
+
+
+# This would be a markaby template for the listwidget. I find it less readable so will not
+# continue working on it.
+#
+#
+#   mab {
+#     div.list do
+#     text @paginate
+#     table do
+#         tr do
+#            @columns.each { |c| td { @query_def.order_by == c[:id] ? text(c[:display]) : Link('', @query_def.to_h('order_by',
+#          end
+#         form(:name=>"#{@list_name}_form", :method=>'POST') do
+#           tr do
+#              @columns.each { |c|
+#                                td {    @ftag = "#{@list_name}_filter_#{c[:id]}"
+#                                        input(:type => 'text', :name => @ftag, :value => @query_def.filters[c[:id]])
+#                                        input(:type=>'submit',:value=>'ok') if (@columns.last[:id] == c[:id])
+#                                   }
+#                            }
+#           end
+#         end
+#         @data.each do |row|
+#              tr do
+#                     row.each_index do |field_idx|
+#                           td { text rewrite_field(row, @columns[field_idx][:id], row[field_idx]) }
+#                     end
+#              end
+#          end # data.each
+#      end  # table.do
+#      end # div.list
+#    } #mab

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

@@ -0,0 +1,167 @@
+
+# QueryDef is a settings class that hold the settings for the query for listwidget
+#
+# FIXME: Change name or put into namespace
+class QueryDef
+ ATTRIBS = ['order_by','range', 'filters']
+ ATTRIBS_ENCODE = 
+    { 
+      'range' => 
+      Proc.new do |e| 
+        "#{e.first}-#{e.last}" 
+      end,
+     'filters' => 
+      Proc.new do |e|  
+        s = ''; 
+        e.each_pair { |k,v| s << "#{k}:#{v};" }; 
+        s 
+      end
+    }
+ ATTRIBS_DECODE = 
+    {
+       'range' => 
+       Proc.new do |e| 
+          Range.new(e.split('-')[0].to_i,e.split('-')[1].to_i) 
+       end,
+       'filters' => 
+       Proc.new do |e| 
+          h = {}
+          e.split(';').each do |p|
+               vals = p.split(':')
+               h[vals[0]] = vals[1] if (vals.size == 2)
+          end
+       h
+       end
+    }
+ ATTRIBS_DEFAULTS = { 'range' => 0..9,
+                      'order_by' => '',
+                      'filters' => {} }
+
+ # take from CGI class
+ def escape(string)
+     string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+      '%' + $1.unpack('H2' * $1.size).join('%').upcase
+    end.tr(' ', '+')
+ end
+ def unescape(string)
+    string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+      [$1.delete('%')].pack('H*')
+    end
+ end
+
+ def method_missing(m, *params)
+   met = m.id2name
+
+   #getter 
+   if (ATTRIBS.include?(met)) then
+     return @data[met] || ATTRIBS_DEFAULT[met].dup
+   end
+ 
+   #setter
+   raise NoMethodError if met[met.size-1].chr != '='
+   raise NoMethodError if params.size != 1
+   met = met[0..met.size-2]		# cut '='
+   if ATTRIBS.include?(met) then
+     @data[met] = params[0]
+   else
+     raise NoMethodError
+   end
+ end
+
+ # value enc/dec
+ def ev_enc(name)
+#   $stderr.puts "env_enc(#{name}) #{@data.inspect}"
+   if ATTRIBS_ENCODE.has_key?(name) then
+     ATTRIBS_ENCODE[name].call(@data[name] || '')
+   else
+     @data[name]
+   end
+ end
+
+ def ev_dec(name, value)
+   if ATTRIBS_DECODE.has_key?(name) then
+#     $stderr.puts "ev_dec #{name} #{value}"
+     begin
+        return ATTRIBS_DECODE[name].call(value)
+     rescue
+#        $stderr.puts "Decoding failed: #{name} - #{value}: #{$!}"
+        return ATTRIBS_DEFAULTS[name].dup
+     end
+   else
+     return value
+   end
+ end
+
+ # attribute-name enc/dec
+ def at_enc(name)
+   "#{@list_name}_#{name}"
+ end
+
+ def at_dec(name)
+    name[@list_name.size..@name.size-1]
+ end
+
+ # returns an hash with the values and escaped names and attributes
+ # attr and newval with swap a value for this return without changing the actual data
+ def to_h(attr=nil, newval=nil)
+   if attr then
+      @backup = @data.dup
+      @data[attr] = newval
+   end
+
+   u = {}
+   ATTRIBS.each do |a|
+#      $stderr.puts "Encoding: #{a} - #{@data[a]}"
+      u[at_enc(a)] = escape(ev_enc(a) || '')
+   end
+   
+   if attr then @data = @backup end
+
+   return u
+ end
+
+ def from_params(params)
+#   $stderr.puts "CGI PARAMS: #{$cgi.params.inspect}"
+#   $stderr.puts "*** From Params\n #{params.inspect}\n"
+#   $stderr.puts "*** DEFAULT ATTR: #{ATTRIBS_DEFAULTS.inspect}\n"
+   ATTRIBS.each do |a|
+#     $stderr.puts "Checking: #{at_enc(a)} = #{params[at_enc(a)][0]}"
+     v = params[at_enc(a)]
+     if v then 
+       @data[a] = ev_dec(a,v)
+     else
+       @data[a] = ATTRIBS_DEFAULTS[a].dup
+     end
+#     $stderr.puts "\n*** ENDFROM_PARAMS: #{@data.inspect}"
+   end
+
+   # checking on filters that come by post
+#   $stderr.puts "PARAMS: #{params.inspect}"
+   params.each_pair do |p,v|
+      if p.include?("#{@list_name}_filter_") then
+         @data['filters'] ||= {}
+         fname = p.scan(/\_filter\_(.*)/)[0][0]
+         fdata = v
+         @data['filters'][fname] = fdata
+#         $stderr.puts "Filter update: #{@data['filters'].inspect}"
+      end
+   end
+
+  
+#   $stderr.puts @data.to_yaml
+   return self
+ end
+
+ def initialize(list_name)
+  @list_name = list_name 
+  @data = {}
+ end
+end
+
+# qr = QueryDef.new("my_list")
+# qr.order_by = 'firstname'
+# qr.range = 100..200
+#
+# qr.filters = {'firstname' => 'martin', 'lastname' =>  'boese' }
+# puts qr.to_url
+

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

@@ -0,0 +1,79 @@
+require 'cuca/stdlib/listwidget/list'
+
+
+# Displays data from memory
+#
+# Example:
+#
+# StaticDataList('list_name',
+#           :columns => [ { :id => 'id',    :display=>'ID' },
+#                         { :id => 'name',  :display=>'Name' } ],
+#           :data    => [[ 1, 'Jack'],
+#                        [ 2, 'Elvis'],
+#                        [ 3, 'Alice']])
+class StaticDataListWidget < BaseList
+ def setup
+   super
+ end
+
+ def output(list_name = "noname", data_setup = {})
+   @sd_columns = data_setup[:columns] || []
+   @sd_data    = data_setup[:data] || []
+   @list_name = list_name
+   setup
+   @sd_columns.freeze
+   @sd_data.freeze
+   super(@list_name)
+ end
+ 
+ def columns
+   return @sd_columns
+ end
+
+ def filter(data, column_name, value)
+   cidx = col_idx_by_id(column_name)
+   return data if cidx.nil?
+   return data if value.strip.empty?
+
+   new_data = []
+   data.each_index do |didx|
+     if data[didx][cidx].instance_of?(String) then
+#         $stderr.puts "Filter: #{@data[didx][cidx]} on #{value}"
+         new_data << data[didx] if data[didx][cidx].include?(value)
+#         $stderr.puts @new_data.inspect
+     end
+   end
+#   $stderr.puts "Filter done(#{column_name}, #{value}): #{new_data.inspect}"
+   return new_data
+ end
+
+ def apply_filters(query_def)
+   query_def.filters.each_pair do |k,v|
+     @data = filter(@data, k,v)
+   end
+#   $stderr.puts "Done filtering: #{@data.inspect}"
+ end
+
+
+
+ def query(query_def)
+   cidx = col_idx_by_id(query_def.order_by) || 0
+   
+   @data = @sd_data.sort { |a,b| a[cidx] <=> b[cidx] }
+   apply_filters(query_def)
+   @total_rows = @data.size
+   @data = @data[query_def.range]
+   
+ end
+
+ def col_idx_by_id(col)
+   @sd_columns.each_index do |idx|
+      if @sd_columns[idx][:id] == col then
+        return idx
+      end 
+   end
+   return nil
+ end
+
+end
+

data/lib/cuca/stdlib/slink.rb

@@ -0,0 +1,30 @@
+# Simple, fast link - no markaby as block
+
+class SLinkWidget < Cuca::Widget
+ 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, text = nil, params = {}, tag_attrib = {}) 
+   @attribs = tag_attrib
+   @attribs[:href] = build_href(target, params) 
+  
+   @_content = "<a "
+   @attribs.each_pair do |k,v| 
+      @_content << "#{k}='#{v}'"
+   end
+   @_content << ">#{text || target}</a>"
+
+ end
+end

data/lib/cuca/test/helpers.rb

@@ -0,0 +1,42 @@
+
+require 'test/unit'
+
+module Cuca
+module Test
+
+# Some function that should help you testing your widgets and controllers
+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}))
+ @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.
+def widget(widget_class, *args, &block)
+ a = {}
+ instance_variables.each do |v|
+       a[v.gsub(/\@/,'')] = self.instance_variable_get(v)
+ end
+ return widget_class.new({:assigns => a, :args => args}, &block)
+end
+
+# same as above but enable the profiler to stdout
+def widget_p(widget_class, *args, &block)
+ a = {}
+ instance_variables.each do |v|
+       a[v.gsub(/\@/,'')] = self.instance_variable_get(v)
+ end
+ return widget_class.new({:assigns => a, :args => args, :profiler => $stdout}, &block)
+end
+
+
+end
+end
+end
+