zena 0.15.0

data/lib/zena/use/i18n.rb

@@ -0,0 +1,247 @@
+module Zena
+  module Use
+    module I18n
+      module Common
+
+        def format_date(thedate, theformat = nil, tz_name=nil, lang=visitor.lang)
+          format = theformat || '%Y-%m-%d %H:%M:%S'
+          return "" unless thedate
+          if tz_name
+            # display time local to event's timezone
+            begin
+              tz = TZInfo::Timezone.get(tz_name)
+            rescue TZInfo::InvalidTimezoneIdentifier
+              return "<span class='parser_error'>invalid timezone #{tz_name.inspect}</span>"
+            end
+          else
+            tz = visitor.tz
+          end
+          if thedate.kind_of?(Time)
+            utc_date = thedate
+            adate = tz.utc_to_local(thedate)
+          elsif thedate.kind_of?(String)
+            begin
+              adate    = Date.parse(thedate)
+              utc_date = adate
+
+            rescue
+              # only return error if there is a format (without = used in sql query)
+              return theformat ? "<span class='parser_error'>invalid date #{thedate.inspect}</span>" : Time.now.strftime('%Y-%m-%d %H:%M:%S')
+            end
+          else
+            adate    = thedate
+            utc_date = adate
+          end
+
+          # TODO: REFACTOR TO something like:
+          # with_locale(lang) do
+          # ...
+          # end
+          if visitor.lang != lang
+            ::I18n.locale = lang
+          end
+
+          if format =~ /^age\/?(.*)$/
+            format = $1.blank? ? _('long_date') : $1
+            # how long ago/in how long is the date
+            # FIXME: when using 'age', set expire_at (+1 minute, +1 hour, +1 day, never)
+            age = (Time.now.utc - utc_date) / 60
+
+            if age > 7 * 24 * 60
+              # far in the past, use strftime
+            elsif age >= 2 * 24 * 60
+              # days
+              return _("%{d} days ago") % {:d => (age/(24*60)).floor}
+            elsif age >= 24 * 60
+              # days
+              return _("yesterday")
+            elsif age >= 2 * 60
+              # hours
+              return _("%{h} hours ago") % {:h => (age/60).floor}
+            elsif age >= 60
+              return _("1 hour ago")
+            elsif age > 2
+              # minutes
+              return _("%{m} minutes ago") % {:m => age.floor}
+            elsif age > 0
+              return _("1 minute ago")
+            elsif age >= -1
+              return _("in 1 minute")
+            elsif age > -60
+              return _("in %{m} minutes") % {:m => -age.ceil}
+            elsif age > -2 * 60
+              return _("in 1 hour")
+            elsif age > -24 * 60
+              return _("in %{h} hours") % {:h => -(age/60).ceil}
+            elsif age > -2 * 24 * 60
+              return _("tomorrow")
+            elsif age > -7 * 24 * 60
+              return _("in %{d} days") % {:d => -(age/(24*60)).ceil}
+            else
+              # too far in the future, use strftime
+            end
+          end
+
+          # month name
+          format = format.gsub("%b", _(adate.strftime("%b")) )
+          format.gsub!("%B", _(adate.strftime("%B")) )
+
+          # weekday name
+          format.gsub!("%a", _(adate.strftime("%a")) )
+          format.gsub!("%A", _(adate.strftime("%A")) )
+
+          if visitor.lang != lang
+            ::I18n.locale = visitor.lang
+          end
+
+          adate.strftime(format)
+        end
+
+      end # Common
+
+      module FormatDate
+
+        # display the time with the format provided by the translation of 'long_time'
+        def long_time(atime)
+          format_date(atime, _("long_time"))
+        end
+
+        # display the time with the format provided by the translation of 'short_time'
+        def short_time(atime)
+          format_date(atime, _("short_time"))
+        end
+
+        # display the time with the format provided by the translation of 'full_date'
+        def full_date(adate)
+          format_date(adate, _("full_date"))
+        end
+
+        # display the time with the format provided by the translation of 'long_date'
+        def long_date(adate)
+          format_date(adate, _("long_date"))
+        end
+
+        # display the time with the format provided by the translation of 'short_date'
+        def short_date(adate)
+          format_date(adate, _("short_date"))
+        end
+
+        # format a date with the given format. Translate month and day names.
+        def tformat_date(thedate, fmt)
+          format_date(thedate, _(fmt))
+        end
+      end
+
+      module ControllerMethods
+        include Common
+
+        def self.included(base)
+          base.before_filter { FastGettext.text_domain = 'zena' }
+        end
+
+        # Choose best language to display content.
+        # 1. 'test.host/oo?lang=en' use 'lang', redirect without lang
+        # 3. 'test.host/oo' use visitor[:lang]
+        # 4. 'test.host/'   use session[:lang]
+        # 5. 'test.host/oo' use visitor lang
+        # 6. 'test.host/'   use HTTP_ACCEPT_LANGUAGE
+        # 7. 'test.host/'   use default language
+        #
+        # 8. 'test.host/fr' the redirect for this rule is called once we are sure the request is not for document data (lang in this case can be different from what the visitor is visiting due to caching optimization)
+        def set_lang
+          if params[:prefix] =~ /^\d+$/
+            # this has nothing to do with set_lang...
+            # 'test.host/34' --> /en/node34.html
+            redirect_to "/#{prefix}/#{params[:prefix]}"
+            return false
+          end
+
+          chosen_lang = nil
+          [
+            params[:lang],
+            visitor.is_anon? ? session[:lang] : visitor.lang,
+            (request.headers['HTTP_ACCEPT_LANGUAGE'] || '').split(',').sort {|a,b| (b.split(';q=')[1] || 1.0).to_f <=> (a.split(';q=')[1] || 1.0).to_f }.map {|l| l.split(';')[0].split('-')[0] },
+            (visitor.is_anon? ? visitor.lang : nil), # anonymous user's lang comes last
+          ].compact.flatten.uniq.each do |l|
+            if current_site.lang_list.include?(l)
+              chosen_lang = l
+              break
+            end
+          end
+
+          set_visitor_lang(chosen_lang || current_site[:default_lang])
+          true
+        end
+
+        def set_visitor_lang(l)
+          return unless current_site.lang_list.include?(l)
+          session[:lang] = l
+
+          if visitor.lang != l && !visitor.is_anon?
+            visitor.update_attribute('lang', l)
+          else
+            visitor.lang = l
+          end
+
+          if File.exist?("#{Zena::ROOT}/locale/#{l}/LC_MESSAGES/zena.mo")
+            ::I18n.locale = l
+          else
+            ::I18n.locale = 'en'
+          end
+        end
+
+        # Redirect on lang change "...?lang=de"
+        def check_lang
+          if params[:lang]
+            # redirects other controllers (users controller, etc)
+            redirect_url = params
+            redirect_url.delete(:lang)
+            if params[:controller] == 'nodes'
+              redirect_to redirect_url.merge(:prefix => prefix) and return false
+            else
+              redirect_to redirect_url and return false
+            end
+          end
+          true
+        end
+
+        def set_encoding
+          headers['Content-Type'] ||= 'text/html'
+          if headers['Content-Type'].starts_with?('text/') and !headers['Content-Type'].include?('charset=')
+            headers['Content-Type'] += '; charset=utf-8'
+          end
+        end
+
+      end
+
+      module ViewMethods
+        def self.included(base)
+          base.send(:alias_method_chain, :will_paginate, :i18n) if base.respond_to?(:will_paginate)
+        end
+
+        include Common
+        include FormatDate
+
+        # Enable translations for will_paginate
+        def will_paginate_with_i18n(collection, options = {})
+          will_paginate_without_i18n(collection, options.merge(:prev_label => _('img_prev_page'), :next_label => _('img_next_page')))
+        end
+
+        # translation of static text using gettext
+        # FIXME: I do not know why this is needed in order to have <%= _('blah') %> find the translations on some servers
+        def _(str)
+          ApplicationController.send(:_, str)
+        end
+
+        # Show a little [xx] next to the title if the desired language could not be found. You can
+        # use a :text => '(lang)' option. The word 'lang' will be replaced by the real value.
+        def check_lang(obj, opts={})
+          wlang = (opts[:text] || '[#LANG]').sub('#LANG', obj.version.lang).sub('_LANG', _(obj.version.lang))
+          obj.version.lang != lang ? "<#{opts[:wrap] || 'span'} class='#{opts[:class] || 'wrong_lang'}'>#{wlang}</#{opts[:wrap] || 'span'}>" : ""
+        end
+
+      end # ViewMethods
+
+    end # I18n
+  end # Use
+end # Zena

data/lib/zena/use/nested_attributes_alias.rb

@@ -0,0 +1,201 @@
+module Zena
+  module Use
+    module NestedAttributesAlias
+      # Lets you use nested_attributes_alias methods in forms:
+      # <%= text_field 'v_title' %>
+      module ViewMethods
+        class InstanceTag < ActionView::Helpers::InstanceTag
+          def value(object)
+            if object.respond_to?(:nested_model_names_for_alias) && nested_model_names = object.nested_model_names_for_alias(@method_name)
+              method_name = nested_model_names.pop # remove method
+              nested_model_names.each do |nested_model_name|
+                object = object.send(nested_model_name)
+              end
+              self.class.value(object, method_name)
+            else
+              self.class.value(object, @method_name)
+            end
+          end
+
+          def value_before_type_cast(object)
+            if object.respond_to?(:nested_model_names_for_alias) && nested_model_names = object.nested_model_names_for_alias(@method_name)
+              method_name = nested_model_names.pop # remove method
+              nested_model_names.each do |nested_model_name|
+                object = object.send(nested_model_name)
+              end
+              self.class.value_before_type_cast(object, method_name)
+            else
+              self.class.value_before_type_cast(object, @method_name)
+            end
+          end
+        end
+
+        def text_field(object_name, method, options = {})
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("text", options)
+        end
+
+        def password_field(object_name, method, options = {})
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("password", options)
+        end
+
+        def hidden_field(object_name, method, options = {})
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("hidden", options)
+        end
+
+        def file_field(object_name, method, options = {})
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("file", options)
+        end
+
+        def text_area(object_name, method, options = {})
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_text_area_tag(options)
+        end
+
+        def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_check_box_tag(options, checked_value, unchecked_value)
+        end
+
+        def radio_button(object_name, method, tag_value, options = {})
+          ViewMethods::InstanceTag.new(object_name, method, self, options.delete(:object)).to_radio_button_tag(tag_value, options)
+        end
+      end
+
+
+      # Adds a class method called 'resolve_attributes_alias' to rewrite attributes.
+      #
+      # Example:
+      #
+      # class Foo < ActiveRecord::Base
+      #   include Zena::Use::NestedAttributesAlias::ModelMethods
+      #   has_one :redaction
+      #   nested_attributes_alias /^r_(.+)/ => 'redaction'
+      # end
+      #
+      module ModelMethods
+        def self.included(base)
+          base.extend  Zena::Use::NestedAttributesAlias::ClassMethods
+          if !base.method_defined?(:attributes_without_nested_alias=)
+            base.class_eval do
+              alias_method_chain :attributes=, :nested_alias
+            end
+          end
+        end
+
+        def attributes_with_nested_alias=(*args)
+          self.attributes_without_nested_alias = resolve_attributes_alias(*args)
+        end
+
+        def resolve_attributes_alias(attributes)
+          new_attributes = {}
+          attributes.each do |k, v|
+            if nested_model_names = nested_model_names_for_alias(k)
+              if new_key = nested_model_names.pop
+                v = v.stringify_keys if v.kind_of?(Hash)
+                merge_nested_model_names_in_hash(new_attributes, nested_model_names.map {|nested_model_name| "#{nested_model_name}_attributes"})[new_key] = v
+              end
+            else
+              deep_merge_hash(new_attributes, k => v)
+            end
+          end
+          new_attributes
+        end
+
+        def nested_model_names_for_alias(attribute)
+          attribute = attribute.to_s
+          nested_model_names = nil
+          self.class.nested_attr_alias_list.each do |regexp, target|
+            if attribute =~ regexp
+              if target.kind_of?(Proc)
+                if nested_model_names = target.call(self, $~.to_a)
+                  break
+                end
+              else
+                nested_model_names = target + [$1]
+                break
+              end
+            end
+          end
+          nested_model_names
+        end
+        private
+
+          def merge_nested_model_names_in_hash(target, nested_model_names)
+            nested_model_names.each do |model_name|
+              target = target[model_name] ||= {}
+            end
+            target
+          end
+
+          def deep_merge_hash(target, hash)
+            deep_target = target
+            hash.each do |k, v|
+              if v.kind_of?(Hash)
+                deep_target = target[k.to_s] ||= {}
+                deep_target = deep_merge_hash(deep_target, v)
+              elsif v.kind_of?(Hash)
+                deep_target[k.to_s] = v.stringify_keys
+              else
+                deep_target[k.to_s] = v
+              end
+            end
+          end
+      end # ModelMethods
+
+      module ClassMethods
+        @@_nested_attr_alias      ||= {} # defined for each class
+        @@_nested_attr_alias_list ||= {} # full list with inherited attributes
+
+        # Return the list of all ordered routes, including routes defined in the superclass
+        def nested_attr_alias_list
+          @@_nested_attr_alias_list[self] ||= if superclass.respond_to?(:nested_attributes_alias)
+            # merge with superclass attributes
+            list = superclass.nested_attr_alias_list.dup
+            (@@_nested_attr_alias[self] || []).each do |regex, method|
+              list.reject! do |k, v|
+                # allow new rule to overwrite parent rule
+                k == regex
+              end
+              list << [regex, method]
+            end
+            list
+          else
+            # top class, nothing to inherit
+            @@_nested_attr_alias[self] || []
+          end
+        end
+
+        def nested_attributes_alias(definitions)
+          list = (@@_nested_attr_alias[self] ||= [])
+          definitions.each do |regexp, target|
+            # allow new rule to overwrite rule previously defined
+            list.reject! {|k, v| k == regexp}
+
+            if target.kind_of?(String)
+              target = target.split(".")
+            end
+            list << [regexp, target]
+          end
+        end
+
+        # Same as model method but will not take Proc type resolution. This
+        # could be used by RubyLess to resolve 'v_title' into ==> version ==> title
+        # we will see...
+        def nested_model_names_for_alias(attribute)
+          attribute = attribute.to_s
+          nested_model_names = nil
+          nested_attr_alias_list.each do |regexp, target|
+            if attribute =~ regexp
+              if target.kind_of?(Proc)
+                # ignore
+              else
+                nested_model_names = target + [$1]
+                break
+              end
+            end
+          end
+          nested_model_names
+        end
+      end # ClassMethods
+
+    end # NestedAttributesAlias
+  end # Use
+end # Zena

data/lib/zena/use/node_query_finders.rb

@@ -0,0 +1,491 @@
+require 'query_builder'
+# Since NodeQuery uses a special scope (secure_scope) that needs to be evaluated _in the query string_, you cannot
+# use query.sql. You have to use: eval query.to_s. This is not an issue since normal useage for NodeQuery is to be
+# compilated into an ERB template.
+class NodeQuery < QueryBuilder
+  attr_reader :context, :uses_node_name, :node_name
+  set_main_table 'nodes'
+  set_main_class 'Node'
+  @@filter_fields = {'id' => {:key => 'zip'}}
+
+  # TODO: should glob SITES_ROOT/**/custom_queries...
+  load_custom_queries File.join(File.dirname(__FILE__), 'custom_queries')
+
+  def self.insert_zero_link(link_class)
+    return if link_class.find_by_id(0)
+    link_class.connection.execute "INSERT INTO #{link_class.table_name} (id,target_id,source_id,status,comment) VALUES (0,0,0,NULL,NULL)"
+    unless link_class.find_by_id(0)
+      # the zero id is replaced by auto-increment value
+      last_id = link_class.find(:first, :order => 'id DESC').id
+      link_class.connection.execute "UPDATE #{link_class.table_name} SET id = 0 WHERE id = #{last_id}"
+    end
+  end
+
+  def self.add_filter_field(key, fld_def)
+    @@filter_fields[key] = fld_def
+  end
+
+  def initialize(query, opts = {})
+    @uses_node_name = false
+    @table_name = 'nodes'
+    @node_name  = opts[:node_name]
+    # list of dyna_attributes keys allready in the filter
+    @dyn_keys   = {}
+    super(query, opts)
+    # Raw filters are statements prepared that should not be further processed except for table_name replacement.
+    parse_raw_filters(opts[:raw_filters])
+  end
+
+  # Build joins and filters from a relation.
+  def parse_relation(rel, context)
+    # join_relation first so we can overwrite 'class' finders (images) with a relation.
+    unless join_relation(rel, context) || context_relation(rel, context)
+      @errors << "unknown relation '#{rel}'"
+    end
+  end
+
+  # Default sort order
+  def default_order_clause
+    "position ASC, name ASC"
+  end
+
+  def default_context_filter
+    'self'
+  end
+
+  def after_parse
+    @where.unshift "(\#{#{@node_name}.secure_scope('#{table}')})"
+    if @tables.include?('links')
+      link_table = table('links')
+      @select << "#{link_table}.id AS link_id,#{Zena::Use::Relations::LINK_ATTRIBUTES.map {|l| "#{link_table}.#{l} AS l_#{l}"}.join(',')}"
+    elsif @errors_unless_safe_links
+      @errors += @errors_unless_safe_links
+    end
+    @distinct = true if @tables.include?('versions')
+  end
+
+  # Erb finder used by zafu
+  def finder(count)
+    return 'nil' unless valid?
+    case count
+    when :count
+      "#{node_name}.do_find(:count, #{self.to_s(:count)}, #{!uses_node_name}, #{main_class})"
+    else
+      "#{node_name}.do_find(#{count.inspect}, #{self.to_s}, #{!uses_node_name}, #{main_class})"
+    end
+  end
+
+  private
+    # Make sure all alternate queries include "links.id = 0" (dummy link)
+    def fix_where_list(where_list)
+      return unless @tables.include?('links')
+      where_list.each do |f|
+        unless f =~ /links\./
+          f << " AND links.id = 0"
+        end
+      end
+      true
+    end
+
+    # Used to resolve 'in' clauses ('in project', 'in parent', etc)
+    def context_filter_fields(rel, is_last = false)
+      case rel
+      when 'self'
+        ['parent_id', 'id']
+      when 'parent'
+        is_last ? ['parent_id', 'parent_id'] : ['parent_id', 'id']
+      when 'project'
+        is_last ? ['project_id', 'project_id'] : ['project_id', 'id']
+      when 'section'
+        is_last ? ['section_id', 'section_id'] : ['section_id', 'id']
+      when 'site', main_table
+        :void
+      else
+        nil
+      end
+    end
+
+    # Relations that can be resolved without a join
+    def context_relation(rel, context)
+      case rel
+      when 'self'
+        fields = ['id', 'id']
+      when 'parent', 'project', 'section'
+        fields = ['id', "#{rel}_id"]
+      when 'parents', 'projects', 'sections'
+        if @table_counter[main_table] > 0 || @tables.include?('links')
+          fields = ['id', "#{rel[0..-2]}_id"]
+        end
+      when 'root'
+        @where << "#{table}.id = #{current_site.root_id}"
+        return true
+      when 'author', 'traductions', 'versions'
+        # TODO: not implemented yet...
+        return nil
+      when 'visitor'
+        @where << "#{table}.id = #{insert_bind("visitor.contact_id")}"
+        return true
+      end
+
+      unless fields
+        if klass = Node.get_class(rel)
+          parse_context(default_context_filter) unless context
+          @where << "#{table}.kpath LIKE '#{klass.kpath}%'"
+          return true
+        else
+          # unknown class
+          return nil
+        end
+      end
+
+      @where << "#{field_or_attr(fields[0])} = #{field_or_attr(fields[1], table(main_table,-1))}"
+      true
+    end
+
+    def parse_change_class(rel, is_last)
+      case rel
+      when 'comment', 'comments'
+        if is_last
+          # no need to load discussions, versions and all the mess
+          add_table('comments')
+          @where << "#{table('comments')}.discussion_id = #{map_attr('discussion_id')}"
+          return CommentQuery # class change
+        else
+          # parse_context(default_context_filter, true) if is_last
+          # after_parse
+          add_table('discussions')
+          add_table('comments')
+          @where << "#{table('discussions')}.node_id = #{table('nodes')}.id"
+          @where << "#{table('comments')}.discussion_id = #{table('discussions')}.id"
+          after_parse
+          return CommentQuery
+        end
+      else
+        return nil
+      end
+    end
+
+    # Filters that need a join
+    def join_relation(rel, context, new_table_alias = nil, previous_table_alias = nil)
+      new_table_alias      ||= table(main_table)
+      previous_table_alias ||= table(main_table, -1)
+
+      if rel == main_table || rel == 'children'
+        # dummy clauses
+        parse_context(default_context_filter) unless context
+        return :void
+      end
+
+      if rel = RelationProxy.find_by_role(rel.singularize)
+        # We cannot use a LEFT JOIN here because it will totally mess up if we merge alternate queries
+        add_table('links')
+        # (= other_side = result) target <-- source (= link_side = caller)
+        if context && context != 'self'
+          # tagged in project (not equal to 'tagged from nodes in project')
+          # remove caller join
+          @distinct = true
+          @where << "#{field_or_attr('id', new_table_alias)} = #{table('links')}.#{rel.other_side} AND #{table('links')}.relation_id = #{rel[:id]}"
+        else
+          @where << "#{field_or_attr('id', new_table_alias)} = #{table('links')}.#{rel.other_side} AND #{table('links')}.relation_id = #{rel[:id]} AND #{table('links')}.#{rel.link_side} = #{field_or_attr('id', previous_table_alias)}"
+        end
+      else
+        nil
+      end
+    end
+
+    def map_literal(value, env = :sql)
+      if value =~ /(.*?)\[(visitor|param):(\w+)\](.*)/
+        val_start = $1 == '' ? '' : "#{$1.inspect} +"
+        val_end   = $4 == '' ? '' : "+ #{$4.inspect}"
+        case $2
+        when 'visitor'
+          value = env == :sql ? insert_bind("#{val_start}Node.zafu_attribute(visitor.contact, #{$3.inspect})#{val_end}") : nil
+        when 'param'
+          value = env == :sql ? insert_bind("#{val_start}params[:#{$3}].to_s#{val_end}") : "params[:#{$3}]"
+        end
+      else
+        value = env == :sql ? quote(value) : nil
+      end
+    end
+
+    # Translate fields used for query/sort/grouping (context parameter) into something useable by SQL. Add the appropriate tables when needed.
+    def map_field(field, table_name = table, context = nil)
+      return map_literal("[#{field}]") if field =~ /\Aparam:/
+      case field[0..1]
+      when 'd_'
+        # DYNAMIC ATTRIBUTE
+        key = field[2..-1]
+        key, function = parse_sql_function_in_field(key)
+        key = Zena::Db.sql_function(function, dyn_value('versions', key, context))
+      when 'c_'
+        # CONTENT TABLE
+        field = field[2..-1]
+        # FIXME: implement #41
+        nil
+      when 'v_'
+        # VERSION
+        key = field[2..-1]
+        key, function = parse_sql_function_in_field(key)
+        if Version.safe_method_type([key]) && Version.column_names.include?(key)
+          vtable_name = needs_table('nodes', 'versions', "TABLE1.id = TABLE2.node_id")
+          Zena::Db.sql_function(function, "#{vtable_name}.#{key}")
+        else
+          # bad version attribute
+          nil
+        end
+      when 'l_'
+        key, function = parse_sql_function_in_field(field)
+        if key == 'l_status' || key == 'l_comment' || key == 'l_date' || (key == 'l_id' && [:order, :group].include?(context))
+          @errors_unless_safe_links ||= []
+          @errors_unless_safe_links << "cannot use link field '#{key}' in this query" unless (key == 'l_id' && context == :order)
+          # ok
+          Zena::Db.sql_function(function, "#{table('links')}.#{key[2..-1]}")
+        else
+          # bad attribute
+          nil
+        end
+      else
+        # NODE
+        key, function = parse_sql_function_in_field(field)
+        if context == :filter
+          if map_def = @@filter_fields[key]
+            if table_def = map_def[:table]
+              table_to_use = needs_table(*table_def)
+            else
+              table_to_use = table_name
+            end
+            Zena::Db.sql_function(function, "#{table_to_use}.#{map_def[:key]}")
+          elsif (Node.safe_method_type([key]) && Node.column_names.include?(key))
+            Zena::Db.sql_function(function, "#{table_name}.#{key}")
+          elsif key =~ /^(.*)_ids?$/
+            # tag_id = 33  ===> join links as lk, nodes as tt .......
+            rel = $1
+
+            if RelationProxy.find_by_role(rel.singularize)
+              add_table('jnode', 'nodes')
+              join_relation(rel, nil, table('jnode'), table('nodes'))
+              "#{table('jnode')}.zip"
+            else
+              nil
+            end
+          else
+            nil
+          end
+        else
+          if ['id', 'parent_id','project_id','section_id'].include?(key) || (Node.safe_method_type([key]) && Node.column_names.include?(key))
+            Zena::Db.sql_function(function, "#{table_name}.#{key}")
+          else
+            # bad attribute
+            nil
+          end
+        end
+      end
+    end
+
+    def valid_field?(table_name, fld)
+      # FIXME: security !
+      true
+    end
+
+    def map_attr(fld, env = :sql)
+      case fld
+      when 'project_id', 'section_id', 'discussion_id'
+        @uses_node_name = true
+        insert_bind("#{@node_name}.get_#{fld}")
+      when 'id', 'parent_id'
+        @uses_node_name = true
+        insert_bind("#{@node_name}.#{fld}")
+      else
+        # type = Node.safe_method_type([fld])
+        # type[:method] ?
+
+        # bad parameter
+        @errors << "invalid parameter '#{fld}'"
+        "0"
+      end
+    end
+
+    def parse_paginate_clause(paginate)
+      return @offset unless paginate
+      if !@limit
+        # TODO: raise error ?
+        @errors << "invalid paginate clause '#{paginate}' (used without limit)"
+        nil
+      elsif (fld = map_literal("[param:#{paginate}]", :ruby)) && (page_size = @limit[/ LIMIT (\d+)/,1])
+        @page_size = [2,page_size.to_i].max
+        " OFFSET #{insert_bind("((#{fld}.to_i > 0 ? #{fld}.to_i : 1)-1)*#{page_size.to_i}")}"
+      else
+        @errors << "invalid paginate clause '#{paginate}'"
+        nil
+      end
+    end
+
+    # When a field is defined as log_at:year, return [log_at, year].
+    def parse_sql_function_in_field(field)
+      if field =~ /\A(\w+):(\w+)\Z/
+        if ['year'].include?($2)
+          [$1,$2]
+        else
+          [$1]
+        end
+      else
+        [field]
+      end
+    end
+
+    def parse_raw_filters(filters)
+      return unless filters
+      filters.each do |f|
+        all_ok = true
+        filter = f.gsub(/TABLE_NAME(\[(\w+)\]|)/) do
+          if $2
+            if @table_counter[$2]
+              table($2)
+            else
+              all_ok = false
+              @errors << "invalid table_name '#{$2}' in raw filter"
+              @errors.uniq!
+            end
+          else
+            table
+          end
+        end
+        @where << filter if all_ok
+      end
+    end
+
+    def dyn_value(table_name, key, context)
+      @dyn_keys[table_name] ||= {}
+      @dyn_keys[table_name][key] ||= begin
+        needs_table('nodes', 'versions', "TABLE1.id = TABLE2.node_id")
+        dtable = needs_join_table('versions', 'LEFT', 'dyn_attributes', "TABLE1.id = TABLE2.owner_id AND TABLE2.key = #{quote(key)}", "versions=dyn_attributes=#{key}")
+        "#{dtable}.value"
+      end
+    end
+
+    def parse_custom_query_argument(key, value)
+      return nil unless value
+      super.gsub(/(RELATION_ID|NODE_ATTR)\(([^)]+)\)/) do
+        type, value = $1, $2
+        if type == 'RELATION_ID'
+          role = value
+          if rel = RelationProxy.find_by_role(role.singularize)
+            rel[:id]
+          else
+            @errors << "could not find Relation '#{role}' in custom query"
+            '-1'
+          end
+        elsif type == 'NODE_ATTR'
+          attribute = value
+          if Node.safe_method_type([attribute])
+            insert_bind("#{@node_name}.#{attribute}")
+          else
+            @errors << "cannot read attribute '#{attribute}' in custom query"
+            '-1'
+          end
+        end
+      end.gsub(/NODE_ID/) do
+        @uses_node_name = true
+        insert_bind("#{@node_name}.id")
+      end
+    end
+
+    def extract_custom_query(list)
+      super.singularize
+    end
+
+    def quote(literal)
+      Node.connection.quote(literal)
+    end
+end
+
+module Zena
+  module Use
+    module NodeQueryFinders
+      module AddUseNodeQueryMethod
+        def self.included(base)
+          # create class methods
+          base.extend AddUseNodeQueryMethodImpl
+        end
+      end
+
+      module AddUseNodeQueryMethodImpl
+        def use_node_query
+          class_eval do
+            include Zena::Use::NodeQueryFinders::InstanceMethods
+            class << self
+              include Zena::Use::NodeQueryFinders::ClassMethods
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+
+        # Return an sql query string that will be used by 'do_find':
+        # build_find(:all, PSEUDO_SQL, node_name) => "SELECT * FROM nodes WHERE nodes.parent_id = #{@node[:id]} AND ..."
+        # PSEUDO_SQL: what to find in pseudo sql (See NodeQuery for details).
+        # node_name: contextual variable name
+        #
+        # Pseudo sql syntax:
+        #
+        # '[CLASS|VCLASS|RELATION] [in [site|section|project|parent]|] [where CLAUSE|] [from SUB_QUERY|] or [PSEUDO_SQL]'
+        #
+        # with :
+        #   * CLASS:  a native class ('images', 'documents', 'pages', 'projects', ...)
+        #   * VCLASS: a virtual class created by the user ('posts', 'houses', ...)
+        #   * RELATION: a relation defined by the user ('icon_for', 'news', 'calendar', ...)
+        #   * CLAUSE: field = value ('log_at:year = 2005'). You can use parameters, visitor data in clause: 'log_at:year = [param:year]', 'd_assigned = [visitor:name]'. You can only use 'and' in clauses. 'or' is not supported. You can use version and/or dynamic attributes : 'v_comment = super', 'd_priority = low'.
+        #
+        # Examples: 'todos in section where d_priority = high and d_assigned = [visitor:name]'
+        #def build_find(count, pseudo_sql, node_name, raw_filters = nil, ignore_warnings = false, ref_date = nil)
+        def build_find(count, pseudo_sql, opts = {})
+          if count == :first
+            opts[:limit] = 1
+          end
+          NodeQuery.new(pseudo_sql, opts.merge(:custom_query_group => visitor.site.host))
+        end
+      end # ClassMethods
+
+
+      module InstanceMethods
+
+        # Find a node and propagate visitor
+        def do_find(count, query, ignore_source = false, klass = Node)
+          return nil if query.empty?
+          return nil if (new_record? && !ignore_source) # do not run query (might contain nil id)
+
+          case count
+          when :all
+            res = klass.find_by_sql(query)
+            secure_result(Node,res)
+          when :first
+            res = klass.find_by_sql(query).first
+            secure_result(Node,res)
+          when :count
+            klass.count_by_sql(query)
+          else
+            nil
+          end
+        end
+
+        # Find related nodes.
+        # See Node#build_find for details on the options available.
+        def find(count, rel)
+          rel = [rel] if rel.kind_of?(String)
+
+          if rel.size == 1 && self.class.zafu_known_contexts[rel.first]
+            self.send(rel.first)
+          else
+            query = Node.build_find(count, rel, :node_name => 'self')
+            if query.valid?
+              do_find(count, eval(query.to_s))
+            else
+              nil
+            end
+          end
+        end
+      end # InstanceMethods
+    end # NodeQueryFinders
+  end # Use
+end # Zena