zena 0.15.2 → 0.16.0

data/lib/zafu/ajax.rb

@@ -0,0 +1,93 @@
+module Zafu
+  module Ajax
+    # TODO: write a test (please)
+    # FIXME: we should use a single way to change a whole context into a template (applies to 'each', 'form', 'block'). Then 'swap' could use the 'each' block.
+    # Define a block of elements to be used by ajax calls (edit/filter)
+    def r_block
+      if @context[:block] == self
+        # called from self (storing template)
+        @context.reject! do |k,v|
+          # FIXME: reject all stored elements in a  better way then this
+          k.kind_of?(String) && k =~ /\ANode_\w/
+        end
+        @html_tag_done = false
+        @html_tag_params.merge!(:id=>erb_dom_id)
+        @context[:scope_node] = node if @context[:scope_node]
+        out expand_with(:node => node)
+        if @method == 'drop' && !@context[:make_form]
+          out drop_javascript
+        end
+      else
+        if parent.method == 'each' && @method == parent.single_child_method
+          # use parent as block
+          # FIXME: will not work with block as distant target...
+          # do nothing
+        else
+          @html_tag ||= 'div'
+          new_dom_scope
+
+          unless @context[:make_form]
+            # STORE TEMPLATE ========
+
+            context_bak = @context.dup # avoid side effects when rendering the same block
+            ignore_list = @method == 'block' ? ['form'] : [] # do not show the form in the normal template of a block
+            template    = expand_block(self, :block=>self, :list=>false, :saved_template=>true, :ignore => ignore_list)
+            @context    = context_bak
+            @result     = ''
+            out helper.save_erb_to_url(template, template_url)
+
+            # STORE FORM ============
+            if edit = descendant('edit')
+              publish_after_save = (edit.params[:publish] == 'true')
+              if form = descendant('form')
+                # USE BLOCK FORM ========
+                form_text = expand_block(form, :saved_template=>true, :publish_after_save => publish_after_save)
+              else
+                # MAKE A FORM FROM BLOCK ========
+                form = self.dup
+                form.method = 'form'
+                form_text = expand_block(form, :make_form => true, :list => false, :saved_template => true, :publish_after_save => publish_after_save)
+              end
+              out helper.save_erb_to_url(form_text, form_url)
+            end
+          end
+
+          # RENDER
+          @html_tag_done = false
+          @html_tag_params.merge!(:id=>erb_dom_id)
+        end
+
+        out expand_with
+        if @method == 'drop' && !@context[:make_form]
+          out drop_javascript
+        end
+      end
+    end
+
+    protected
+      # Used by [each] and [draggable] to insert 'id' and drag handle span
+      def set_drag_handle_and_id(text, params, id_hash)
+        res, drag_handle = text, nil
+        if params[:drag_handle]
+          drag_handle = params[:drag_handle] == 'true' ? 'drag_handle' : params[:drag_handle]
+          if text =~ /class\s*=\s*['"]#{drag_handle}/
+            # nothing to do
+            insert = ''
+          else
+            insert = "<span class='#{drag_handle}'>&nbsp;</span>"
+          end
+        else
+          insert = ''
+        end
+
+        res = insert + text
+
+        if id_hash
+          @html_tag ||= 'div'
+          @html_tag_params.merge!(id_hash)
+        end
+
+        [res, drag_handle]
+      end
+  end # Ajax
+end # Zafu

data/lib/zafu/attributes.rb

@@ -0,0 +1,117 @@
+module Zafu
+  # All this should be replaced by RubyLess
+  module Attributes
+    include RubyLess::SafeClass
+
+    PSEUDO_ATTRIBUTES = {
+      'now'      => 'Time.now',
+      'start.id' => '(params[:s] || @node[:zip])',
+      'nil'      => 'nil',
+    }
+
+
+    def node_attribute(str, opts={})
+
+      if @context[:vars] && @context[:vars].include?(str)
+        return "set_#{str}"
+      end
+
+      res = PSEUDO_ATTRIBUTES[str]
+      return res if res
+      return current_date  if str == 'current_date'
+      return get_param($1) if str =~ /^param:(\w+)$/
+
+      attribute, att_node, klass = get_attribute_and_node(str)
+
+      return 'nil' unless attribute
+
+
+      att_node  ||= opts[:node]       || node
+      klass     ||= opts[:node_class] || node_class
+
+      real_attribute = attribute =~ /\Ad_/ ? attribute : attribute.gsub(/\A(|[\w_]+)id(s?)\Z/, '\1zip\2')
+
+      if klass.ancestors.include?(Node)
+        if ['url','path'].include?(real_attribute)
+          # pseudo attribute 'url'
+          params = {}
+          params[:mode]   = @params[:mode]   if @params[:mode]
+          params[:format] = @params[:format] if @params[:format]
+          res = "zen_#{real_attribute}(#{node}#{params_to_erb(params)})"
+        elsif type = safe_method_type([real_attribute])
+          res = type[:method]
+        elsif type = klass.safe_method_type([real_attribute])
+          res = "#{att_node}.#{type[:method]}"
+        else
+          res = "#{att_node}.safe_read(#{real_attribute.inspect})"
+        end
+      elsif type = RubyLess::SafeClass.safe_method_type_for(klass, [real_attribute])
+        res = "#{att_node}.#{type[:method]}"
+      elsif klass.instance_methods.include?('safe_read')
+        # Unknown method but safe class: can resolve at runtime
+        res = "#{att_node}.safe_read(#{real_attribute.inspect})"
+      else
+        out parser_error("#{klass} does not respond to #{real_attribute.inspect}")
+        return 'nil'
+      end
+
+      res = "(#{res} || #{node_attribute(opts[:else])})" if opts[:else]
+      res = "(#{res} || #{opts[:default].inspect})" if opts[:default]
+      res
+    end
+
+    def parse_attributes_in_value(v, opts = {})
+      opts = {:erb => true}.merge(opts)
+      static = true
+
+      use_node  = @var || node
+      res = v.gsub(/\[([^\]]+)\]/) do
+        static = false
+        res    = nil
+        attribute = $1
+
+        if opts[:skip_node_attributes]
+          if attribute =~ /^param:(\w+)$/
+            attribute = get_param($1)
+          elsif attribute == 'current_date'
+            attribute = current_date
+          else
+            res = "[#{attribute}]"
+          end
+        else
+          attribute = node_attribute(attribute, :node => use_node )
+        end
+
+        res ||= if opts[:erb]
+          "<%= #{attribute} %>"
+        else
+          "\#{#{attribute}}"
+        end
+        res
+      end
+      [res, static]
+    end
+
+    def get_attribute_and_node(str)
+      if str =~ /([^\.]+)\.(.+)/
+        node_name = $1
+        node_attr = $2
+        if att_node = find_stored(Node, node_name)
+          return [node_attr, att_node, Node]
+        elsif node_name == 'main'
+          return [node_attr, '@node', Node]
+        elsif node_name == 'visitor'
+          return [node_attr, 'visitor.contact', Contact]
+        elsif node_name == 'site'
+          return [node_attr, 'current_site', Site]
+        else
+          out parser_error("invalid node name #{node_name.inspect} in attribute #{str.inspect}")
+          return [nil]
+        end
+      else
+        return [str]
+      end
+    end
+
+  end # Attributes
+end # Zafu

data/lib/zafu/calendar.rb

@@ -0,0 +1,159 @@
+module Zafu
+  module Calendar
+
+    def r_calendar
+      if @context[:block] == self
+        # called from self (storing template / rendering)
+        if role = @params[:assign_as]
+          assign_calendar(role)
+        else
+          display_calendar
+        end
+      else
+        # This is called first to prepare calendar
+        if @params[:assign_as]
+          fld = 'date'
+          table_name = 'links'
+        else
+          fld = @params[:date] || 'event_at'
+          if ['log_at', 'created_at', 'updated_at', 'event_at'].include?(fld) # TODO: use rubyless to learn type
+            table_name = 'nodes'
+          elsif fld == 'l_date'
+            fld = 'date'
+            table_name = 'links'
+          else
+            return parser_error("Invalid 'date' value for calendar (#{fld.inspect}).")
+          end
+        end
+
+        @date_scope = "TABLE_NAME[#{table_name}].#{fld} >= '\#{start_date.strftime('%Y-%m-%d')}' AND TABLE_NAME[#{table_name}].#{fld} <= '\#{end_date.strftime('%Y-%m-%d')}'"
+
+        new_dom_scope
+
+        # SAVED TEMPLATE
+        template = expand_block(self, :block => self, :saved_template => true)
+        out helper.save_erb_to_url(template, template_url)
+
+        # INLINE
+        out expand_block(self, :block => self, :saved_template => false)
+      end
+    end
+
+    private
+      def display_calendar
+        size     = (params[:size]  || 'large').to_sym
+        finder   = params[:select] || 'notes in project'
+
+        if @blocks == []
+          # add a default <r:link/> block
+          if size == :tiny
+            @blocks = [make(:void, :method=>'void', :text=>"<em do='link' date='current_date' do='[current_date]' format='%d'/><r:else do='[current_date]' format='%d'/>")]
+          else
+            @blocks = [make(:void, :method=>'void', :text=>"<span do='show' date='current_date' format='%d'/><ul><li do='each' do='link' attr='name'/></ul><r:else do='[current_date]' format='%d'/>")]
+          end
+          remove_instance_variable(:@all_descendants)
+        elsif !descendant('else')
+          @blocks += [make(:void, :method=>'void', :text=>"<r:else do='[current_date]' format='%d'/>")]
+          remove_instance_variable(:@all_descendants)
+        end
+
+        @html_tag_done = false
+        @html_tag_params[:id] = erb_dom_id
+        @html_tag_params[:class] ||= "#{size}cal"
+        @html_tag ||= 'div'
+
+        finder, klass = build_finder_for(:all, finder, @params, [@date_scope])
+        return unless finder
+        return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
+
+        cell_code = "<% if #{list_var} = nodes_#{list_var}[cal_#{list_var}.strftime('%Y-%m-%d %H')] -%>#{expand_with(:in_if => true, :list => list_var, :date => "cal_#{list_var}", :saved_template => nil, :dom_prefix => nil, :in_calendar => true)}<% end -%>"
+
+        render_html_tag(calendar_code(finder, "", cell_code, "", params))
+      end
+
+      # manage links from @node ---- reference ----> ...
+      # <div do='calendar' assign='reference' to='main' split_hours='12' />
+      def assign_calendar(as_role)
+        size = (params[:size]  || 'large').to_sym
+        @html_tag_done = false
+        @html_tag_params[:id] = erb_dom_id
+        @html_tag_params[:class] ||= "#{size}cal"
+        @html_tag ||= 'div'
+        if rel = RelationProxy.find_by_role(as_role.singularize)
+          role = rel.this_role
+        else
+          return parser_error("Invalid role #{as_role.inspect}.")
+        end
+        finder, klass = build_finder_for(:all, role, @params, [@date_scope])
+        return unless finder
+        return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
+
+        # SAVED TEMPLATE ========
+        template_url  = self.template_url + 'cell'
+        template      = "<%= cal_assign_cell(@node, #{role.inspect}, #{@params[:used].inspect}) %>"
+        out helper.save_erb_to_url(template, template_url)
+
+        # we call update on node 'B'
+        # A (main)
+        # ... B (other node)
+        #     calendar (in B context) ---- role --->
+
+        cell_prefix_code = "<span><%= day_#{list_var}.strftime('%d').to_i -%></span><ul>"
+        cell_code = "<%= #{list_var} = nodes_#{list_var}[cal_#{list_var}.strftime('%Y-%m-%d %H')]; #{node}.linked_node = #{list_var} ? #{list_var}.first : nil; cal_assign_cell(#{node}, #{role.inspect}, #{@params[:used].inspect}, params[:s] || @node.zip, cal_#{list_var}, #{template_url.inspect}) %>"
+        cell_postfix_code = "</ul>"
+        render_html_tag(calendar_code(finder, cell_prefix_code, cell_code, cell_postfix_code, params))
+      end
+
+      def calendar_code(finder, cell_prefix_code, cell_code, cell_postfix_code, params)
+        type = params[:type] ? params[:type].to_sym : :month
+        size = (params[:size] || 'large').to_sym
+        ref_date = params[:assign_as] ? 'l_date' : (params[:date] || 'event_at')
+
+        case type
+        when :month
+          title = "\"\#{_(Date::MONTHNAMES[main_date.mon])} \#{main_date.year}\""
+          prev_date = "\#{main_date.advance(:months => -1).strftime(\"%Y-%m-%d\")}"
+          next_date = "\#{main_date.advance(:months =>  1).strftime(\"%Y-%m-%d\")}"
+        when :week
+          title = "\"\#{_(Date::MONTHNAMES[main_date.mon])} \#{main_date.year}\""
+          prev_date = "\#{main_date.advance(:days => -7).strftime(\"%Y-%m-%d\")}"
+          next_date = "\#{main_date.advance(:days => +7).strftime(\"%Y-%m-%d\")}"
+        else
+          return parser_error("invalid type (should be 'month' or 'week')")
+        end
+
+        if hours = @params[:split_hours]
+          hours = hours.split(',').map{|l| l.to_i}
+          hours << 0
+          hours = hours.uniq.sort
+          # I feel all this would be much better if we could use "each_group" but then how do we access hours ?
+          week_code = "<% week.step(week+6,1) do |day_#{list_var}| -%>
+          <td<%= cal_class(day_#{list_var},#{current_date}) %>>#{cell_prefix_code}<% #{hours.inspect}.each do |set_hour|; cal_#{list_var} = Time.utc(day_#{list_var}.year,day_#{list_var}.month,day_#{list_var}.day,set_hour) -%>#{cell_code}<% end -%>#{cell_postfix_code}</td>
+          <% end -%>"
+          (@context[:vars] ||= []) << "hour"
+        else
+          hours = nil
+          week_code = "<% week.step(week+6,1) do |day_#{list_var}| -%>
+          <td<%= cal_class(day_#{list_var},#{current_date}) %>><% cal_#{list_var} = Time.utc(day_#{list_var}.year,day_#{list_var}.month,day_#{list_var}.day) -%>#{cell_prefix_code}#{cell_code}#{cell_postfix_code}</td>
+          <% end -%>"
+        end
+
+        res = <<-END_TXT
+<h3 class='title'>
+<span><%= link_to_remote(#{_('img_prev_page').inspect}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=#{dom_id}&date=#{prev_date}&#{start_node_s_param(:string)}\", :method => :get) %></span>
+<span class='date'><%= link_to_remote(#{title}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=#{dom_id}&#{start_node_s_param(:string)}\", :method => :get) %></span>
+<span><%= link_to_remote(#{_('img_next_page').inspect}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=#{dom_id}&date=#{next_date}&#{start_node_s_param(:string)}\", :method => :get) %></span>
+</h3>
+<table cellspacing='0' class='#{size}cal#{@params[:assign_as] ? " assign" : ''}'>
+<tr class='head'><%= cal_day_names(#{size.inspect}) %></tr>
+<% start_date, end_date = cal_start_end(#{current_date}, #{type.inspect}) -%>
+<% cal_weeks(#{ref_date.to_sym.inspect}, #{finder}, start_date, end_date, #{hours.inspect}) do |week, nodes_#{list_var}| -%>
+<tr class='body'>
+#{week_code}
+</tr>
+<% end -%>
+</table>
+        END_TXT
+      end
+  end # Calendar
+end # Zafu

data/lib/zafu/context.rb

@@ -0,0 +1,330 @@
+module Zafu
+  module Context
+    # TODO: test, rename ?
+    def r_search_results
+      pagination_key = 'page'
+      out "<% set_#{pagination_key}_nodes = @search_count; set_#{pagination_key}_count = (set_#{pagination_key}_nodes / @search_per_page).ceil; set_#{pagination_key} = [1,params[:page].to_i].max -%>"
+      @context[:vars] ||= []
+      @context[:vars] << "#{pagination_key}_nodes"
+      @context[:vars] << "#{pagination_key}_count"
+      @context[:vars] << pagination_key
+      @context[:paginate] = pagination_key
+      do_list('@nodes')
+    end
+
+    # FIXME: replace by rubyless declarations
+    def r_comments_to_publish
+      open_context(:method => 'visitor.comments_to_publish', :class => [Comment])
+    end
+
+    def r_to_publish
+      open_context(:method => 'visitor.to_publish', :class => [Version])
+    end
+
+    def r_proposed
+      open_context(:method => 'visitor.proposed', :class => [Version])
+    end
+
+    def r_redactions
+      open_context(:method => 'visitor.redactions', :class => [Version])
+    end
+
+    protected
+
+      # FIXME: we should replace this with @context.find_context(finder) and move it into Zafu core.
+      def change_context(rel, opts = {})
+        # FIXME: replace with RubyLess.translate(rel)
+        raw_filters = opts[:raw_filters] || []
+
+        signature = [rel]
+        unless params.empty?
+          signature += [Hash[*params.map{|k,v| [k,String]}.flatten]]
+        end
+
+        if !opts[:skip_rubyless] && context = RubyLess::SafeClass.safe_method_type_for(node_class, signature)
+          if params.empty?
+            return context.merge(:method => "#{node}.#{context[:method]}")
+          else
+            return context.merge(:method => "#{node}.#{context[:method]}(#{params.inspect})")
+          end
+        end
+
+        rel ||= 'self'
+
+        # TODO: simplify !
+        count   = opts[:find] || (['first','all','count'].include?(@params[:find]) ? @params[:find].to_sym : nil)
+
+        # count ||= Node.plural_relation?(method) ? :all : :first
+        unless count
+          if params[:paginate] || child['each'] || child['group'] || Node.plural_relation?(rel)
+            count = :all
+          else
+            count = :first
+          end
+        end
+
+
+        if (count == :first)
+          if rel == 'self'
+            return {:method => node, :class => node_class}
+          elsif rel == 'main'
+            return {:method => '@node', :class => Node}
+          elsif rel == 'root'
+            return {:method => "(secure(Node) { Node.find(#{current_site[:root_id]})})", :class => Node}
+          elsif rel == 'start'
+            return {:method => 'start_node', :class => Node}
+          elsif rel == 'visitor'
+            return {:method => 'visitor.contact', :class => Contact}
+          elsif rel =~ /^\d+$/
+            return {:method => "(secure(Node) { Node.find_by_zip(#{rel.inspect})})", :class => Node}
+          elsif node_name = find_stored(Node, rel)
+            return {:method => node_name, :class => Node}
+          elsif rel[0..0] == '/'
+            rel = rel[1..-1]
+            return {:method => "(secure(Node) { Node.find_by_path(#{rel.inspect})})", :class => Node}
+          end
+        end
+
+        pseudo_sql, add_raw_filters = make_pseudo_sql(rel, params)
+        raw_filters += add_raw_filters if add_raw_filters
+
+        # FIXME: stored should be clarified and managed in a single way through links and contexts.
+        # <r:void store='foo'>...
+        # <r:link href='foo'/>
+        # <r:pages from='foo'/> <-- this is just a matter of changing node parameter
+        # <r:pages from='site' project='foo'/>
+        # <r:img link='foo'/>
+        # ...
+
+        if node_kind_of?(Node)
+          node_name = @context[:parent_node] || node
+        else
+          node_name = @context[:previous_node]
+        end
+
+        # make sure we do not use a new record in a find query:
+        query = Node.build_find(count, pseudo_sql, :node_name => node_name, :raw_filters => raw_filters, :ref_date => "\#{#{current_date}}")
+
+        unless query.valid?
+          out parser_error(query.errors.join(' '), pseudo_sql.join(', '))
+          return nil
+        end
+
+
+        if count == :count
+          out "<%= #{query.finder(:count)} %>"
+          return nil
+        end
+
+        klass = query.main_class
+
+        if params[:else]
+          # FIXME: else not working with safe_method_type ?
+          finder, else_class, else_query = build_finder_for(count, params[:else], {})
+          if finder && (else_query.nil? || else_query.valid?) && (else_class == klass || klass.ancestors.include?(else_class) || else_class.ancestors.include?(klass))
+            klass = [klass] if count == :all
+            {:method => "(#{query.finder(count)} || #{finder})", :class => klass, :query => query}
+          else
+            klass = count == :all ? [query.main_class] : query.main_class
+            {:method => query.finder(count), :class => klass, :query => query}
+          end
+        else
+          # FIXME: query_builder should respond to safe_type ===> {:method => ..., :class => ...}
+          klass = count == :all ? [query.main_class] : query.main_class
+          {:method => query.finder(count), :class => klass, :query => query}
+        end
+      end
+
+      # Create an sql query to open a new context (passes its arguments to HasRelations#build_find)
+      def build_finder_for(count, rel, params=@params, raw_filters = [])
+        if (context = RubyLess::SafeClass.safe_method_type_for(node_class, [rel])) && !params[:in] && !params[:where] && !params[:from] && !params[:order] && raw_filters == []
+          klass = context[:class]
+
+          if klass.kind_of?(Array) && count == :all
+            return ["#{node}.#{rel}", klass[0]]
+          else
+            return [(count == :all ? "[#{node}.#{rel}]" : "#{node}.#{rel}"), klass]
+          end
+        end
+
+        rel ||= 'self'
+        if (count == :first)
+          if rel == 'self'
+            return [node, node_class]
+          elsif rel == 'main'
+            return ["@node", Node]
+          elsif rel == 'root'
+            return ["(secure(Node) { Node.find(#{current_site[:root_id]})})", Node]
+          elsif rel == 'start'
+            return ["start_node", Node]
+          elsif rel == 'visitor'
+            return ["visitor.contact", Node]
+          elsif rel =~ /^\d+$/
+            return ["(secure(Node) { Node.find_by_zip(#{rel.inspect})})", Node]
+          elsif node_name = find_stored(Node, rel)
+            return [node_name, Node]
+          elsif rel[0..0] == '/'
+            rel = rel[1..-1]
+            return ["(secure(Node) { Node.find_by_path(#{rel.inspect})})", Node]
+          end
+        end
+
+        pseudo_sql, add_raw_filters = make_pseudo_sql(rel, params)
+        raw_filters += add_raw_filters if add_raw_filters
+
+        # FIXME: stored should be clarified and managed in a single way through links and contexts.
+        # <r:void store='foo'>...
+        # <r:link href='foo'/>
+        # <r:pages from='foo'/> <-- this is just a matter of changing node parameter
+        # <r:pages from='site' project='foo'/>
+        # <r:img link='foo'/>
+        # ...
+
+        if node_kind_of?(Node)
+          node_name = @context[:parent_node] || node
+        else
+          node_name = @context[:previous_node]
+        end
+
+        # make sure we do not use a new record in a find query:
+        query = Node.build_find(count, pseudo_sql, :node_name => node_name, :raw_filters => raw_filters, :ref_date => "\#{#{current_date}}")
+
+        unless query.valid?
+          out parser_error(query.errors.join(' '), pseudo_sql.join(', '))
+          return nil
+        end
+
+
+        if count == :count
+          out "<%= #{query.finder(:count)} %>"
+          return nil
+        end
+
+        klass = query.main_class
+
+        if params[:else]
+          # FIXME: else not working with safe_method_type ?
+          finder, else_class, else_query = build_finder_for(count, params[:else], {})
+          if finder && (else_query.nil? || else_query.valid?) && (else_class == klass || klass.ancestors.include?(else_class) || else_class.ancestors.include?(klass))
+            ["(#{query.finder(count)} || #{finder})", klass, query]
+          else
+            [query.finder(count), query.main_class, query]
+          end
+        else
+          [query.finder(count), query.main_class, query]
+        end
+      end
+
+      # Build pseudo sql from the parameters
+      # comments where ... from ... in ... order ... limit
+      def make_pseudo_sql(rel, params=@params)
+        parts   = [rel.dup]
+        filters = []
+
+        if params[:from]
+          parts << params[:from]
+
+          key_counter = 1
+          while sub_part = params["from#{key_counter}".to_sym]
+            key_counter += 1
+            parts << sub_part
+          end
+        end
+
+        if params[:where]
+          parts[0] << " where #{params[:where]}"
+        end
+
+        if params[:in]
+          parts[-1] << " in #{params[:in]}"
+        end
+
+        if group = params[:group]
+          parts[-1] << " group by #{group}" unless parts[0] =~ /group by/
+        end
+
+        if order = params[:order]
+          parts[-1] << " order by #{order}" unless parts[0] =~ /order by/
+        end
+
+        if paginate = params[:paginate]
+          page_size = params[:limit].to_i
+          page_size = 20 if page_size < 1
+          parts[-1] << " limit #{page_size} paginate #{paginate.gsub(/[^a-z_A-Z]/,'')}"
+        else
+          [:limit, :offset].each do |k|
+            next unless params[k]
+            parts[-1] << " #{k} #{params[k]}" unless parts[0] =~ / #{k} /
+          end
+        end
+
+        finders = [parts.join(' from ')]
+        if params[:or]
+          finders << params[:or]
+
+          key_counter = 1
+          while sub_or = params["or#{key_counter}".to_sym]
+            key_counter += 1
+            finders << sub_or
+          end
+        else
+          or_clause = nil
+        end
+
+        return [finders, parse_raw_filters(params)]
+      end
+
+      # Parse special filters
+      def parse_raw_filters(params)
+        filters = []
+
+        if value = params[:author]
+          if stored = find_stored(User, value)
+            filters << "TABLE_NAME.user_id = '\#{#{stored}.id}'"
+          elsif value == 'current'
+            filters << "TABLE_NAME.user_id = '\#{#{node}[:user_id]}'"
+          elsif value == 'visitor'
+            filters << "TABLE_NAME.user_id = '\#{visitor[:id]}'"
+          elsif value =~ /\A\d+\Z/
+            filters << "TABLE_NAME.user_id = '#{value.to_i}'"
+          elsif value =~ /\A[\w\/]+\Z/
+            # TODO: path, not implemented yet
+          end
+        end
+
+        if value = params[:project]
+          if stored = find_stored(Node, value)
+            filters << "TABLE_NAME.project_id = '\#{#{stored}.get_project_id}'"
+          elsif value == 'current'
+            filters << "TABLE_NAME.project_id = '\#{#{node}.get_project_id}'"
+          elsif value =~ /\A\d+\Z/
+            filters << "TABLE_NAME.project_id = '#{value.to_i}'"
+          elsif value =~ /\A[\w\/]+\Z/
+            # TODO: path, not implemented yet
+          end
+        end
+
+        if value = params[:section]
+          if stored = find_stored(Node, value)
+            filters << "TABLE_NAME.section_id = '\#{#{stored}.get_section_id}'"
+          elsif value == 'current'
+            filters << "TABLE_NAME.section_id = '\#{#{node}.get_section_id}'"
+          elsif value =~ /\A\d+\Z/
+            filters << "TABLE_NAME.section_id = '#{value.to_i}'"
+          elsif value =~ /\A[\w\/]+\Z/
+            # not implemented yet
+          end
+        end
+
+        [:updated, :created, :event, :log].each do |k|
+          if value = params[k]
+            # current, same are synonym for 'today'
+            filters << date_condition(value,"TABLE_NAME.#{k}_at",current_date)
+          end
+        end
+
+        filters == [] ? nil : filters
+      end
+
+  end # Context
+end # Zafu