zena 1.0.0.beta3 → 1.0.0.rc1

data/lib/zena/use/query_builder.rb

@@ -1,29 +1,112 @@
 module Zena
   module Use
     module QueryBuilder
+      DATE_FIELD_REGEXP = %r{\d+[\.-/]\d+[\.-/]\d+}
       module ViewMethods
+        include RubyLess
+        safe_method [:query_parse, String] => {:class => String, :accept_nil => true}
+
         def find_node_by_zip(zip)
           return nil unless zip
           secure(Node) { Node.find_by_zip(zip) }
         end
 
-        def query(class_name, node_name, pseudo_sql)
-          klass = get_class(class_name)
-          begin
-            query = klass.build_query(:all, pseudo_sql,
-              :node_name       => node_name,
-              :main_class      => klass,
-              # We use 'zafu_helper' (which is slower) instead of 'self' because our helper needs to have helper modules
-              # mixed in and strangely RubyLess cannot access the helpers from 'self'.
-              :rubyless_helper => zafu_helper.helpers
-            )
-          rescue ::QueryBuilder::Error => err
-            # FIXME: how to return error messages to the user ?
-            nil
+        def query(class_name, node_name, pseudo_sql, opts = {})
+          type = opts[:type] || :find
+          if klass = VirtualClass[class_name]
+            begin
+              query = klass.build_query(:all, pseudo_sql,
+                :node_name       => node_name,
+                :main_class      => klass,
+                # We use 'zafu_helper' (which is slower) instead of 'self' because our helper needs to have helper modules
+                # mixed in and strangely RubyLess cannot access the helpers from 'self'.
+                :rubyless_helper => zafu_helper.helpers
+              )
+              if type == :count
+                return klass.do_find(:count, eval(query.to_s(:count)))
+              else
+                return klass.do_find(:all, eval(query.to_s))
+              end
+            rescue ::QueryBuilder::Error => err
+              # FIXME: how to return error messages to the user ?
+            end
           end
+          # error
+          type == :count ? 0 : nil
+        end
 
-          klass.do_find(:all, eval(query.to_s))
+        # Takes a hash of parameters and builds query arguments for SQLiss
+        # the query ends up like ' AND param_name = "foo" AND param_name > 35'...
+        def query_parse(params)
+          params ||= {}
+          res = []
+          if params.kind_of?(String)
+            return params
+          elsif params.kind_of?(Hash)
+            params.each do |k,v|
+              clause = query_build_clause(k,v)
+              res << clause unless clause.blank?
+            end
+          end
+          res.empty? ? '1=1' : res.join(' and ')
         end
+
+        private
+          # Transforms special syntax into SQLiss. Argument can be
+          #
+          #    ''          ==> (empty fields are ignored)
+          #    '""'        ==> key = ""
+          #    '"null"'    ==> key = "null"
+          #    'null'      ==> key is null
+          #    'foobar'    ==> key = "foobar"
+          #    '> 45'      ==> key > 45
+          #    '10..20'    ==> key >= 10 and key <= 20
+          #    '%bar'      ==> key like "%bar"
+          #    '"foo%"'    ==> key = "foo%"
+          def query_build_clause(key, arg)
+            first = arg.first
+            return "not (#{query_build_clause(key, arg[1..-1])})" if first == '!'
+            if ["'", '"'].include?(first)
+              return "#{key} = #{arg}"
+            end
+
+            if arg =~ DATE_FIELD_REGEXP
+              arg = query_parse_dates(arg)
+              first = arg.first
+            end
+
+            if ['>','<','='].include?(first)
+              "#{key} #{arg}"
+            elsif arg == 'null'
+              "#{key} is null"
+            elsif arg == ''
+              # ignore
+              ''
+            elsif arg =~ /\*/
+              # like
+              "#{key} like #{arg.gsub('*','%').inspect}"
+            elsif arg =~ /^(.+)\.\.(.+)$/
+              # interval
+              "#{key} >= #{$1} and #{key} <= #{$2}"
+            elsif arg =~ /^\d+$/
+              # number
+              "#{key} = #{arg}"
+            elsif first == "'"
+              "#{key} = #{arg}"
+            else
+              "#{key} = #{arg.inspect}"
+            end
+          end
+
+          def query_parse_dates(str)
+            str.gsub(DATE_FIELD_REGEXP) do |date_str|
+              if date = DateTime.parse(date_str) rescue nil
+                date.strftime("'%Y-%m-%d'")
+              else
+                date_str
+              end
+            end
+          end
       end # ViewMethods
 
       # 1. try Zafu
@@ -38,46 +121,85 @@ module Zena
 
         include RubyLess
         # The :class argument in this method is only used when the String is not a literal value
-        safe_method [:find, String] => {:method => 'nil', :pre_processor => :get_finder_type, :class => NilClass}
-        safe_method [:find, Number] => {:method => :find_node_by_zip, :class => Node, :nil => true, :accept_nil => true}
+        safe_method [:find,  String] => {:method => 'nil', :pre_processor => :get_type_for_find,  :class => NilClass}
+        safe_method [:count, String] => {:method => '0',   :pre_processor => :get_type_for_count, :class => Number  }
+        safe_method [:find,  Number] => {:method => :find_node_by_zip, :class => Node, :nil => true, :accept_nil => true}
 
         def self.included(base)
           base.process_unknown :querybuilder_eval
         end
 
+        # Dynamic query mocks the QueryBuilder::Query
+        class DynamicQuery
+          def initialize(default, node, sql)
+            @default, @node, @sql = default, node, sql
+          end
+
+          def to_s(type = :find)
+            base = "'#{@node.klass}', #{@node.to_s.inspect}, #{@sql}"
+            case type
+            when :find
+              return "query(#{base})"
+            else
+              return "query(#{base}, :type => #{type.inspect})"
+            end
+          end
+
+          # Pass all other methods to the default query.
+          def method_missing(meth, *args)
+            @default.send(meth, *args)
+          end
+        end
+
         # Open a list context with a query comming from the url params. Default param name is
         # "qb"
         def r_query
           return parser_error("Cannot be used in list context (#{node.class_name})") if node.list_context?
-          return parser_error("Missing 'default' query") unless default = @params[:default]
-          return parser_error("No query compiler for (#{node.class_name})") if !node.klass.respond_to?(:build_query)
+          return parser_error("Missing 'default' query") unless default_psql = @params[:default]
 
+          begin
+            default = build_finder(:all, default_psql, {})
+            default_query = default[:query]
+          rescue ::QueryBuilder::Error => err
+            return parser_error(err.message)
+          end
 
-          default_query = build_query(:all, default)
           klass = [default_query.main_class]
 
+          can_be_nil = true
           if sql = @params[:eval]
             sql = RubyLess.translate(self, sql)
             unless sql.klass <= String
               return parser_error("Invalid compilation result for #{sql.inspect} (#{sql.klass})")
             end
-          elsif sql = @params[:text]
+            can_be_nil = sql.opts[:nil]
+          elsif sql = @params[:select]
             sql = RubyLess.translate_string(self, sql)
+            can_be_nil = sql.opts[:nil]
           else
             sql = "params[:qb]"
           end
 
-          method = "query('#{node.klass}', #{node.to_s.inspect}, #{sql} || #{default.inspect})"
+          if can_be_nil
+            sql = "#{sql} || #{default_psql.inspect}"
+          end
 
-          expand_with_finder(:method => method, :class => klass, :nil => true)
+          query = DynamicQuery.new(default_query, node, sql)
+          expand_with_finder(:method => query.to_s, :class => [query.main_class], :nil => true, :query => query)
         end
 
         # Pre-processing of the 'find("...")' method.
-        def get_finder_type(string)
+        def get_type_for_find(string)
           finder = build_finder(:first, string, {})
           TypedString.new(finder.delete(:method), finder)
         end
 
+        # Pre-processing of the 'count("...")' method.
+        def get_type_for_count(string)
+          finder = build_finder(:count, string, {})
+          TypedString.new(finder.delete(:method), finder)
+        end
+
         # Resolve unknown methods by trying to build a pseudo-sql query with QueryBuilder.
         def querybuilder_eval(method = @method)
           return nil if node.klass.kind_of?(Array) # list context
@@ -89,7 +211,11 @@ module Zena
             finder = build_finder(count, method, @params)
           end
 
-          expand_with_finder(finder)
+          if count == :count && @blocks.empty?
+            out "<%= #{finder[:method]} %>"
+          else
+            expand_with_finder(finder)
+          end
         rescue ::QueryBuilder::Error => err
           parser_continue(err.message)
         end
@@ -115,10 +241,14 @@ module Zena
             page_count = get_var_name('paginate', 'count', sub_context)
             curr_page  = get_var_name('paginate', 'current', sub_context)
 
-            # Give access to the pagination key.
+            # Give access to the page number through the pagination key.
             set_context_var('set_var', pagination_key, RubyLess::TypedString.new(curr_page, Number))
+            # Give access to page_count and count
+            # FIXME: DOC
+            set_context_var('set_var', 'page_count', RubyLess::TypedString.new(page_count, Number))
+            set_context_var('set_var', 'count', RubyLess::TypedString.new(node_count, Number))
 
-            out "<% #{node_count} = Node.do_find(:count, #{query.to_s(:count)}); #{page_count} = (#{node_count} / #{query.page_size.to_f}).ceil; #{curr_page} = [1,params[:#{pagination_key}].to_i].max -%>"
+            out "<% #{node_count} = Node.do_find(:count, #{query.to_s(:count)}); #{page_count} = (#{node_count} / #{query.page_size.to_f}).ceil; #{curr_page} = [1,params[:#{pagination_key}].to_i].max %>"
           elsif finder[:method].kind_of?(RubyLess::TypedString)
             # Hash passed with :zafu => {} is inserted into context
             sub_context.merge!(finder[:method].opts[:zafu] || {})
@@ -130,7 +260,7 @@ module Zena
         end
 
         private
-          # Build a Query object from pseudo sql.
+          # Build a Query object from SQLiss.
           def build_query(count, pseudo_sql, raw_filters = [])
 
             if !node.klass.respond_to?(:build_query)
@@ -173,7 +303,7 @@ module Zena
               else_clause = RubyLess.translate(self, else_clause)
 
               if else_clause.klass == Array
-                else_klass = else_clause.opts[:array_content_class]
+                else_klass = else_clause.opts[:elem]
                 if count == :all
                   # Get first common ancestor
                   common_klass = (klass.ancestors & else_klass.ancestors).detect {|x| x.kind_of?(Class)}
@@ -232,7 +362,7 @@ module Zena
             ((params[:paginate] || child['each'] || child['group'] || Node.plural_relation?(method)) ? :all : :first)
           end
 
-          # Build pseudo sql from the parameters
+          # Build SQLiss from the parameters
           # comments where ... from ... in ... order ... limit
           def get_pseudo_sql(rel, params)
             parts   = [rel.dup]

data/lib/zena/use/query_comment.rb

@@ -45,7 +45,7 @@ module Zena
               if $3 == 'user_id'
                 value = "visitor.id"
               else
-                value = "Node.zafu_attribute(visitor.contact, #{$3.inspect})"
+                value = "Node.zafu_attribute(visitor.node, #{$3.inspect})"
               end
             when 'node'
               if $3 == 'user_id'

data/lib/zena/use/query_node.rb

@@ -14,10 +14,17 @@ module Zena
 
       module ModelMethods
         def self.included(base)
-          base.send(:include, ::QueryBuilder)
-          base.extend ClassMethods
-          base.query_compiler = Zena::Use::QueryNode::Compiler
-          base.safe_method :db_attr => StringDictionary
+          base.class_eval do
+            include ::QueryBuilder
+            extend ClassMethods
+            self.query_compiler = Zena::Use::QueryNode::Compiler
+            safe_method :db_attr => StringDictionary
+            safe_method [:first, String]  => {:class => Node, :nil => true, :method => 'safe_first'}
+          end
+        end
+
+        def safe_first(query)
+          find(:first, query, :skip_rubyless => true)
         end
 
         # Find related nodes.
@@ -30,8 +37,8 @@ module Zena
             begin
               query = self.class.build_query(count, rel,
                 :node_name       => 'self',
-                :main_class      => Zena::Acts::Enrollable.make_class(self.vclass),
-                :rubyless_helper => (opts[:rubyless_helper] || self),
+                :main_class      => virtual_class,
+                :rubyless_helper => (opts[:rubyless_helper] || virtual_class), # should it be || self ?
                 :default         => opts[:default]
               )
 
@@ -43,7 +50,7 @@ module Zena
               return opts[:errors] ? err : nil
             end
 
-            type = [:all, :first].include?(count) ? :find : count
+            type = [:all, :first].include?(count) ? :find : :count
 
             self.class.do_find(count, eval(query.to_s(type)))
           end
@@ -80,7 +87,8 @@ module Zena
             res = find_by_sql(query).first
             secure_result(res)
           when :count
-            count_by_sql(query)
+            # query can be a number when we use the 'query' helper to count.
+            query.kind_of?(Fixnum) ? query : count_by_sql(query)
           else
             nil
           end
@@ -92,7 +100,7 @@ module Zena
         set_main_table 'nodes'
         set_main_class 'Node'
         set_default :scope,   'self'
-        set_default :order,   'position ASC, node_name ASC'
+        set_default :order,   'position ASC, title ASC'
         set_default :context, 'self'
         after_process :insert_links_fields
         after_process :secure_query
@@ -101,6 +109,11 @@ module Zena
 
         CORE_CONTEXTS = %w{parent project section}
 
+        # Resolve 'main_class' from a class name.
+        def resolve_main_class(class_name)
+          VirtualClass[class_name]
+        end
+
         class << self
           attr_accessor :filter_fields
 
@@ -109,16 +122,15 @@ module Zena
           end
         end
 
-        # How to treat filters like "where id = 45" or "where parent_id = #{params[:parent_id]}"
+        # Enables filters like "where id = 45" or "where parent_id = #{params[:parent_id]}"
         self.filter_fields = {
-          'id'         => {:key => 'zip'},
-          'parent_id'  => {:key => 'zip', :join => ['nodes', 'nodes', 'TABLE2.id = TABLE1.parent_id AND TABLE2.site_id = TABLE1.site_id']},
-          'project_id' => {:key => 'zip', :join => ['nodes', 'nodes', 'TABLE2.id = TABLE1.project_id AND TABLE2.site_id = TABLE1.site_id']},
-          'section_id' => {:key => 'zip', :join => ['nodes', 'nodes', 'TABLE2.id = TABLE1.section_id AND TABLE2.site_id = TABLE1.site_id']}
+          'id'         => {:key => 'zip'},          # alias   source   target   filter
+          'parent_id'  => {:key => 'zip', :table => ['jnode', 'nodes', 'nodes', 'TABLE2.id = TABLE1.parent_id AND TABLE2.site_id = TABLE1.site_id']},
+          'project_id' => {:key => 'zip', :table => ['jnode', 'nodes', 'nodes', 'TABLE2.id = TABLE1.project_id AND TABLE2.site_id = TABLE1.site_id']},
+          'section_id' => {:key => 'zip', :table => ['jnode', 'nodes', 'nodes', 'TABLE2.id = TABLE1.section_id AND TABLE2.site_id = TABLE1.site_id']},
+          'now'        => Zena::Db::NOW,
         }
 
-        add_filter_field 'now', Zena::Db::NOW
-
         # Scope current context with previous context.
         # For example:
         #                          current         previous
@@ -153,20 +165,49 @@ module Zena
           end
         end
 
+        def get_scope_index_field(field_name)
+          return nil if @query.main_class.real_class.column_names.include?(field_name)
+          # scope index
+          klass = @query.main_class
+          if index_model = klass.kind_of?(VirtualClass) ? klass.idx_class : nil
+            index_model = Zena.resolve_const(index_model) rescue NilClass
+            if index_model < Zena::Use::ScopeIndex::IndexMethods && index_model.column_names.include?(field_name)
+              table_to_use = add_key_value_table('scope_index', index_model.table_name) do |tbl_name|
+                # This block is only executed once
+                add_filter "#{table('nodes')}.id = #{tbl_name}.node_id"
+              end
+              "#{table_to_use}.#{field_name}"
+            else
+              # invalid field_name: ignore
+              nil
+            end
+          else
+            # no index model: ignore
+            nil
+          end
+        end
+
         # Overwrite this and take car to check for valid fields.
         def process_field(field_name)
-          if processing_filter? && map_def = self.class.filter_fields[field_name]
+          if fld = @query.attributes_alias[field_name]
+            # use custom query alias value defined in select clause: 'custom_a AS validation'
+            return processing_filter? ? "(#{fld})" : fld
+          elsif processing_filter? && scope_field = get_scope_index_field(field_name)
+            scope_field
+          elsif processing_filter? && map_def = self.class.filter_fields[field_name]
+            # Special filter fields such as 'role', 'tag' or 'class'
             if map_def.kind_of?(String)
               return map_def
             elsif table_def = map_def[:table]
-              table_to_use = needs_join_table(*table_def)
-            elsif join_def = map_def[:join]
-              # current table
-              first_table  = table(join_def[0])
-              # filter table
-              add_table('jnode', join_def[1]) # join node
-              table_to_use = table('jnode')
-              add_filter join_def[2].gsub('TABLE1', first_table).gsub('TABLE2', table_to_use)
+              use_name, source, target, filter = table_def
+              table_to_use = add_key_value_table(use_name, target, map_def[:key]) do |tbl_name|
+                # This block is only executed once
+                add_filter filter.gsub(
+                  'TABLE1', table(source)
+                ).gsub(
+                  'TABLE2', tbl_name
+                )
+              end
             else
               table_to_use = table
             end
@@ -196,24 +237,34 @@ module Zena
               return res
             end
 
-            column = @query.main_class.schema.columns[field_name]
+            # property or real column
+            column = @query.main_class.columns[field_name]
             if column && column.indexed?
               if column.index == true
                 group_name = column.type
+              elsif column.index =~ Property::Index::FIELD_INDEX_REGEXP
+                # field in nodes
+                return "#{table}.#{$1}"
               else
                 group_name = column.index
               end
 
-              index_table = @query.main_class.index_table_name(group_name)
-              add_table(index_table)
+              index_table = @query.main_class.real_class.index_table_name(group_name)
+
+              # We use the add_key_value_table rule to avoid inserting the
+              # same index access twice.
 
-              add_filter "#{table(index_table)}.node_id = #{table}.id"
-              add_filter "#{table(index_table)}.key = #{quote(field_name)}"
-              if group_name.to_s =~ /^ml_/
-                add_filter "#{table(index_table)}.lang = #{quote(visitor.lang)}"
+              tbl = add_key_value_table(group_name, index_table, field_name) do |tbl_name|
+                # This block is only executed once
+                add_filter "#{tbl_name}.node_id = #{table}.id"
+                add_filter "#{tbl_name}.key = #{quote(field_name)}"
+                if group_name.to_s =~ /^ml_/
+                  add_filter "#{tbl_name}.lang = #{quote(visitor.lang)}"
+                end
+                # no need for distinct, the new table makes a 1-1 relation
               end
-              distinct!
-              "#{table(index_table)}.value"
+
+              "#{tbl}.value"
             else
               super # raises an error
             end
@@ -258,15 +309,56 @@ module Zena
           end
         end
 
+        def resolve_scope_idx_fields(arg1, arg2)
+          if arg1.first == :function
+            # contact.log_at.year
+            # arg1 = [:function, [:field, "tag"], [:method, "created_at"]]
+            # arg2 = [:method, "year"]
+            class_name = arg1[1][1]
+            field_name = arg1[2][1]
+            function  = arg2
+          elsif arg1[0] == :field && arg2[0] == :method
+            # contact.log_at  or  log_at.year
+            # arg1 = [:field, "contact"]
+            # arg2 = [:method, "name"]
+            class_or_field    = arg1[1]
+            field_or_function = arg2[1]
+            if @query.main_class.columns[class_or_field]
+              # log_at.year
+              return [arg1, arg2]
+            else
+              class_name = class_or_field
+              field_name = field_or_function
+              function   = nil
+            end
+          else
+            return [arg1, arg2]
+          end
+
+          scope_idx_field = "#{class_name}_#{field_name}"
+          if get_scope_index_field(scope_idx_field)
+            return [[:field, scope_idx_field], function]
+          else
+            # not a scope index field
+            return [arg1, arg2]
+          end
+        end
+
         def process_function(arg, method)
-          arg, method = process(arg), process(method)
-          Zena::Db.sql_function(method, arg)
+          # Resolve scope index fields
+          arg, method = resolve_scope_idx_fields(arg, method)
+          if method
+            arg, method = process(arg), process(method)
+            Zena::Db.sql_function(method, arg)
+          else
+            process(arg)
+          end
         end
 
         # ******** And maybe overwrite these **********
         def parse_custom_query_argument(key, value)
           return nil unless value
-          super.gsub(/(RELATION_ID|NODE_ATTR)\(([^)]+)\)|(REF_DATE|NODE_ID)/) do
+          super.gsub(/(RELATION_ID|NODE_ATTR)\(([^)]+)\)|(REF_DATE|NODE_ID|VISITOR_LANG)/) do
             type, value = $1, $2
             type ||= $3
             case type
@@ -290,6 +382,8 @@ module Zena
               context[:ref_date] ? insert_bind(context[:ref_date]) : 'now()'
             when 'NODE_ID'
               insert_bind("#{node_name}.id")
+            when 'VISITOR_LANG'
+              insert_bind("visitor.lang")
             end
           end
         end
@@ -303,7 +397,7 @@ module Zena
         # This is used to avoid finding random indexed objects or links in clauses with and without link filters
         # like this: "image or icon" ('image' is a filter in 'parent' scope, 'icon' is a
         # relation found through links).
-        def resolve_missing_table(query, table_alias, table_name)
+        def resolve_missing_table(query, table_name, table_alias)
           if table_name =~ /^idx_nodes/
             # index tables
             query.where.insert 0, "#{table_alias}.node_id = 0"
@@ -345,9 +439,11 @@ module Zena
           def context_relation(relation)
             # Not sure we need all these anymore...
             case relation
-            #when 'self'
-            #  # Dummy context
-            #  fields = ['id', 'id']
+            when 'self'
+              # Special pseudo-context
+              add_table(main_table)
+              add_filter "#{field_or_attr('id')} = #{field_or_attr('id', table(main_table, -1))}"
+              return true
             #when 'parent', 'project', 'section'
             #  # Core contexts
             #  fields = ['id', "#{relation}_id"]
@@ -358,7 +454,7 @@ module Zena
             when 'root'
               # Special pseudo-context
               add_table(main_table)
-              make_and_set_main_class(Project)
+              set_main_class(VirtualClass['Project'])
               add_filter "#{table}.id = #{current_site.root_id}"
               return true
             #when 'author', 'traductions', 'versions'
@@ -367,8 +463,8 @@ module Zena
             when 'visitor'
               # Special pseudo-context
               add_table(main_table)
-              make_and_set_main_class(BaseContact)
-              add_filter "#{table}.id = #{insert_bind("visitor.contact_id")}"
+              set_main_class(VirtualClass.find_by_kpath(visitor.prototype.kpath))
+              add_filter "#{table}.id = #{insert_bind("visitor.node_id")}"
               return true
             end
 
@@ -385,7 +481,7 @@ module Zena
             if class_name
               # We have named the relation, set main_class
               if klass = Node.get_class(class_name)
-                make_and_set_main_class(klass)
+                set_main_class(klass)
               else
                 raise QueryBuilder::QueryException.new("Unknown class #{klass} in scope '#{class_name}:#{scope}'.")
               end
@@ -418,15 +514,16 @@ module Zena
               if klass = @filter_relation_class || Node.get_class(relation)
                 # Relation was found in 'join_relation'
                 @filter_relation_class = nil
-                res_class = make_and_set_main_class(klass)
+                set_main_class(klass)
+                res_class = klass
 
                 add_table(main_table)
                 add_filter "#{table}.kpath LIKE #{quote("#{res_class.kpath}%")}" unless res_class.kpath == 'N'
                 true
               elsif role = Node.get_role(relation)
-                klass = Zena::Acts::Enrollable.make_class(@query.main_class)
-                klass.has_role role
-                set_main_class(klass)
+                if klass = VirtualClass.find_by_kpath(role.kpath)
+                  set_main_class(klass)
+                end
 
                 add_table(main_table)
                 add_table('nodes_roles')
@@ -459,7 +556,7 @@ module Zena
                 add_table(use_name, main_table)
               else
                 add_table(main_table)
-                make_and_set_main_class(rel.other_klass)
+                set_main_class(rel.other_vclass)
               end
 
               add_table('links')
@@ -508,12 +605,6 @@ module Zena
           def node_name
             @context[:node_name]
           end
-
-          def make_and_set_main_class(klass)
-            res_class = Zena::Acts::Enrollable.make_class(klass)
-            set_main_class(res_class)
-            res_class
-          end
       end # Compiler
     end # QueryNode
   end # Use