zena 0.16.3 → 0.16.4

data/lib/comment_query.rb

@@ -1,92 +0,0 @@
-require 'querybuilder'
-
-class CommentQuery < QueryBuilder
-  attr_reader :uses_node_name, :node_name
-  set_main_table 'comments'
-  set_main_class 'Comment'
-
-  # Default sort order
-  def default_order_clause
-    "created_at ASC"
-  end
-
-  def default_context_filter
-    # should never be called alone
-    raise Exception.new("CommentQuery should only be called from within NodeQuery")
-  end
-
-  def parse_change_class(rel, is_last)
-    case rel
-    when 'author'
-      add_table('users')
-      @where << "#{table('users')}.id = #{field_or_attr('author_id')}"
-      # should we move on to Contact ?
-    when 'node', 'nodes'
-      add_table('discussions')
-      add_table('nodes')
-      @where << "#{table('discussions')}.id = #{table('comments')}.discussion_id"
-      @where << "#{table('nodes')}.id = #{table('discussions')}.node_id"
-      return NodeQuery # class change
-    else
-      return nil
-    end
-  end
-
-  # Same as NodeQuery... DRY needed.
-  def map_literal(value)
-    if value =~ /(.*?)\[(node|visitor|param):(\w+)\](.*)/
-      val_start = $1 == '' ? '' : "#{$1.inspect} +"
-      val_end   = $4 == '' ? '' : "+ #{$4.inspect}"
-      case $2
-      when 'visitor'
-        if $3 == 'user_id'
-          value = "visitor.id"
-        else
-          value = "Node.zafu_attribute(visitor.contact, #{$3.inspect})"
-        end
-      when 'node'
-        @uses_node_name = true
-        if $3 == 'user_id'
-          value = "#{@node_name}.user_id"
-        else
-          value = "Node.zafu_attribute(#{@node_name}, #{$3.inspect})"
-        end
-      when 'param'
-        return "\#{Node.connection.quote(#{val_start}params[:#{$3}].to_s#{val_end})}"
-      end
-
-      if !val_start.blank? || !val_end.blank?
-        "\#{Node.connection.quote(#{val_start}#{value}#{val_end})}"
-      else
-        "\#{#{value}}"
-      end
-    else
-      value = Node.connection.quote(value)
-    end
-  end
-
-  # Overwrite this and take car to check for valid fields.
-  def map_field(fld, table_name, context = nil)
-    if ['status', 'updated_at', 'author_name', 'created_at', 'title', 'text', 'author_id'].include?(fld)
-      "#{table_name}.#{fld}"
-    else
-      # TODO: error, raise / ignore ?
-    end
-  end
-
-  def map_attr(fld)
-    # error
-    nil
-  end
-
-  # Erb finder used by zafu
-  def finder(count)
-    return 'nil' unless valid?
-    case count
-    when :count
-      "#{node_name}.do_find(:count, #{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
-end

data/lib/image_builder.rb

@@ -1,325 +0,0 @@
-require 'tempfile'
-require 'digest/sha1'
-unless defined?(Magick)
-  begin
-    # this works on the deb box
-    require 'RMagick'
-  rescue LoadError
-    begin
-      # this works on my Mac
-      require 'rmagick'
-    rescue LoadError
-      puts "ImageMagick not found. Using dummy."
-      require 'ftools'
-      # Create a dummy magick module
-      module Magick
-        CenterGravity = OverCompositeOp = MaxRGB = NorthGravity = SouthGravity = nil
-        class << self
-        end
-        class ZenaDummy
-          def initialize(*a)
-          end
-          def method_missing(meth, *args)
-            # do nothing
-          end
-        end
-        class Image < ZenaDummy
-        end
-        class ImageList < ZenaDummy
-        end
-      end
-    end
-  end
-end
-
-class ImageBuilder
-  DEFAULT_FORMATS = {
-    'tiny' =>   { :name=>'tiny', :size=>:force, :width=>16,  :height=>16 , :gravity=>Magick::CenterGravity   },
-    'mini' =>   { :name=>'mini', :size=>:force, :width=>32,  :height=>32 , :gravity=>Magick::CenterGravity   },
-    'square' => { :name=>'square', :size=>:limit, :width=>180, :height=>180, :gravity=>Magick::CenterGravity },
-    'med'  =>   { :name=>'med',  :size=>:limit, :width=>280, :height=>186, :gravity=>Magick::CenterGravity   },
-    'top'  =>   { :name=>'top',  :size=>:force, :width=>280, :height=>186, :gravity => Magick::NorthGravity  },
-    'low'  =>   { :name=>'low',  :size=>:force, :width=>280, :height=>186, :gravity => Magick::SouthGravity  },
-    'side' =>   { :name=>'side', :size=>:force, :width=>220, :height=>500, :gravity=>Magick::CenterGravity   },
-    'std'  =>   { :name=>'std',  :size=>:limit, :width=>600, :height=>400, :gravity=>Magick::CenterGravity   },
-    'pv'   =>   { :name=>'pv',   :size=>:force, :width=>70,  :height=>70 , :gravity=>Magick::CenterGravity   },
-    'edit' =>   { :name=>'edit', :size=>:limit, :width=>400, :height=>400, :gravity=>Magick::CenterGravity   },
-    'full' =>   { :name=>'full', :size=>:keep                            , :gravity=>Magick::CenterGravity   },
-    nil    =>   { :name=>'full', :size=>:keep                            , :gravity=>Magick::CenterGravity   },
-  }.freeze
-  # 'sepia'=>   { :size=>:limit, :width=>280, :ratio=>2/3.0, :post=>Proc.new {|img| img.sepiatone(Magick::MaxRGB * 0.8)}},
-
-  class << self
-    def image_content_type?(content_type)
-      content_type =~ /image/
-    end
-
-    def dummy?
-      Magick.const_defined?(:ZenaDummy)
-    end
-
-    def hash_id(format)
-      Digest::SHA1.hexdigest("#{format[:name]}#{format[:size]}#{format[:width]}#{format[:height]}#{format[:gravity]}")[0..9].to_i(16)
-    end
-
-    DEFAULT_FORMATS.each do |k, v|
-      v[:hash_id] = ImageBuilder.hash_id(v)
-      v.freeze
-    end
-  end
-
-  def initialize(h)
-    params = {:height=>nil, :width=>nil, :path=>nil, :file=>nil, :actions=>[]}.merge(h)
-
-    params.each do |k,v|
-      case k
-      when :height
-        @height = v if v
-      when :width
-        @width = v if v
-      when :path
-        @path = v if v
-      when :file
-        @file = v if v
-      when :actions
-        if v.kind_of?(Array)
-          @actions = v
-        else
-          raise StandardError, "Bad actions format"
-        end
-      else
-        raise StandardError, "Bad parameter (#{k})"
-      end
-    end
-    unless @width && @height || dummy?
-      if @img = build_image_from_file_or_path
-        @width  = @img.columns
-        @height = @img.rows
-      end
-    end
-  end
-
-  def dummy?
-    ImageBuilder.dummy? || (!@path && !@img && !@file)
-  end
-
-  def read
-    return nil if dummy?
-    render_img
-    @img.to_blob
-  end
-
-  def write(path)
-    return false if dummy?
-    render_img
-    @img.write(path)
-  end
-
-  def rows
-    return nil unless @height || !dummy?
-    (@height ||= render_img.rows).round
-  end
-
-  def columns
-    return nil unless @width || !dummy?
-    (@width ||= render_img.columns).round
-  end
-
-  alias height rows
-  alias width columns
-
-  def resize!(s)
-    # we do not zoom pixels
-    return unless s < 1.0
-    @img = nil # reset current rendered image
-    @width  *= s
-    @height *= s
-    @actions << Proc.new {|img| img.resize!(s) }
-  end
-
-  def crop!(x,y,w,h)
-    @img = nil # reset current rendered image
-    @width  = [@width -x, w].min
-    @height = [@height-y, h].min
-    @actions << Proc.new {|img| img.crop!(x,y,[@img.columns-x, w].min,[@img.rows-y, h].min, true) }
-  end
-
-  def format=(fmt)
-    return unless !dummy? && Magick.formats[fmt.upcase] =~ /w/
-    @actions << Proc.new {|img| img.format = fmt.upcase; img }
-  end
-
-  def format
-    render_img.format
-  end
-
-  def exif
-    @exif ||= ExifData.new(render_img.get_exif_by_entry)
-  end
-
-  def max_filesize=(size)
-    @actions << Proc.new {|img| do_limit!(size) }
-  end
-
-  def do_limit!(size)
-    return @img if @filesize <= size
-
-    # Check real size
-    tmp_path = Tempfile.new('tmp_img').path
-    @img.write('jpeg:' + tmp_path)
-
-    return @img if File.stat(tmp_path).size <= size
-
-    # Change type to JPG and quality to 80
-    if (@img.format == 'JPG' || @img.format == 'JPEG') && @img.quality > 80
-      @img.write('jpeg:' + tmp_path) { self.quality = 80 }
-    else
-      @img.format = 'JPG'
-      @img.write('jpeg:' + tmp_path) { self.quality = 80 }
-    end
-    ratio = File.stat(tmp_path).size.to_f / size
-
-    return @img = Magick::ImageList.new(tmp_path) if ratio <= 1.0
-
-    # Not enough ? Resize.
-    ratio   = 1.0 / Math.sqrt(ratio)
-    @width  *= ratio
-    @height *= ratio
-    @img.resize!(ratio)
-    @img
-  end
-
-  def crop_min!(w,h,gravity=Magick::CenterGravity)
-    @img = nil # reset current rendered image
-    @width  = [@width ,w].min
-    @height = [@height,h].min
-    @actions << Proc.new {|img| img.crop!(gravity,[@img.columns,w].min,[@img.rows,h].min, true) }
-  end
-
-  def set_background!(opacity,w,h)
-    @img = nil # reset current rendered image
-    @width  = [@width ,w].max
-    @height = [@height,h].max
-    @actions << Proc.new do |img|
-      bg = Magick::Image.new(w,h)
-      bg.opacity = opacity
-      bg.format = img.format
-      img = bg.composite(img, Magick::CenterGravity, Magick::OverCompositeOp)
-    end
-  end
-
-  # Transform into another format. If nil : do nothing.
-  def transform!(tformat=nil)
-    return self unless tformat
-    @img = nil
-    format = { :size=>:limit, :gravity=>Magick::CenterGravity }.merge(tformat)
-    @pre, @post = format[:pre], format[:post]
-
-    if format[:size] == :keep
-      h,w = @height, @width
-    else
-      h,w = format[:height], format[:width]
-    end
-    if format[:scale]
-      if h || w
-        # scale is a pre-zoom before crop
-        scale = format[:scale]
-      else
-        # we resize to scale
-        h,w = @height*format[:scale], @width*format[:scale]
-        # but we do not zoom
-        scale = 1.0
-        # ignore ':size' format if not height nor width was given
-        format[:size] = :force
-      end
-    else
-      scale = 1.0
-    end
-    if format[:ratio] && h && !w
-      w = h / format[:ratio]
-    elsif format[:ratio] && w && !h
-      h = w * format[:ratio]
-    end
-
-    pw,ph = @width, @height
-    if [w,h,pw,ph].include?(nil) || [w,h,pw,ph].min <= 0
-      # image size or thumb size is null (no image processing tool used, no idea on image size)
-      if format[:size] == :keep
-        @height, @width = nil, nil
-      else
-        @height, @width = h, w
-      end
-      return self
-    end
-
-    case format[:size]
-    when :force
-      crop_scale = [w.to_f/pw, h.to_f/ph].max
-      if crop_scale > 1.0
-        # we do not zoom. Fill with transparent background.
-        crop_min!(w,h,format[:gravity])
-        set_background!(Magick::MaxRGB, w, h)
-      else
-        resize!(crop_scale * scale)
-        crop_min!(w, h,format[:gravity])
-      end
-    when :force_no_crop
-      crop_scale = [w.to_f/pw, h.to_f/ph].min
-      resize!(crop_scale * scale)
-      crop_min!(w, h,format[:gravity])
-      set_background!(Magick::MaxRGB, w, h)
-    when :limit
-      crop_scale = [w.to_f/pw, h.to_f/ph].min
-      resize!(crop_scale * scale)
-      crop_min!(w, h,format[:gravity])
-    when :keep
-    end
-    self
-  end
-
-  def render_img
-    raise IOError, 'MagickDummy cannot render image' if ImageBuilder.dummy?
-    unless @img
-      unless @img = build_image_from_file_or_path
-        raise IOError, 'Cannot render image without path or file'
-      end
-      if @pre
-        @pre = [@pre].flatten
-        @pre.each do |a|
-          @img = a.call(@img)
-        end
-      end
-
-      if @actions
-        @actions.each do |a|
-          @img = a.call(@img)
-        end
-      end
-
-      if @post
-        @post = [@post].flatten
-        @post.each do |a|
-          @img = a.call(@img)
-        end
-      end
-    end
-    @img
-  end
-
-  def build_image_from_file_or_path
-    if @file || @path
-      if @file.kind_of?(StringIO)
-        img = Magick::ImageList.new
-        @file.rewind
-        img.from_blob(@file.read)
-        @file.rewind
-        @filesize = @file.size
-        img
-      else
-        img = Magick::ImageList.new(@file ? @file.path : @path)
-        @filesize = img.filesize
-        img
-      end
-    end
-  end
-end

data/lib/zena/use/node_query_finders.rb

@@ -1,494 +0,0 @@
-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'}}
-
-  load_custom_queries ["#{RAILS_ROOT}/bricks/*/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|node):(\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}]"
-        when 'node'
-          @uses_node_name = true
-          value = env == :sql ? insert_bind("#{val_start}#{@node_name}.safe_read(#{$3.inspect}).to_s#{val_end}") : "#{@node_name}.safe_read(#{$3.inspect})"
-        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.
-        # TODO: replace with rubyless translate ? Is this thing really used anyway ?
-        def find(count, rel, opts = {})
-          rel = [rel] if rel.kind_of?(String)
-
-          if !opts[:skip_rubyless] && rel.size == 1 && type = RubyLess::SafeClass.safe_method_type_for(self.class, [rel.first])
-            self.send(type[:method])
-          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