spiderfw 0.6.19 → 0.6.20

data/CHANGELOG

@@ -1,3 +1,10 @@
+= 0.6.20
+== 05 October, 2011
+* Added support for aggregate functions in DB conditions
+* Added after_load event to Form widget to allow manipulation of the loaded object
+* Fixed error Table Widget when paginate attribute is set to false
+* Improved DB join generation
+
 = 0.6.19
 == 21 September, 2011
 * Fixes: DbMapper join logic, configuration editor, js files compilation, Rack set_body_io (used by SOAP)

data/VERSION

@@ -1 +1 @@
-0.6.19
+0.6.20

data/apps/config_editor/_init.rb

@@ -11,5 +11,4 @@ Spider::Template.register_namespace('config_editor', Spider::ConfigEditor)
 
 
 require 'apps/config_editor/controllers/config_editor_controller'
-require 'apps/config_editor/widgets/edit/edit'
-require 'apps/config_editor/widgets/edit_bool/edit_bool'
+require 'apps/config_editor/widgets/edit/edit'

data/apps/config_editor/controllers/config_editor_controller.rb

@@ -75,13 +75,7 @@ module Spider; module ConfigEditor
         end
         
         def create_edit_widget(key, option)
-            wclass = case option[:params][:type].name
-            when 'Spider::Bool', 'Spider::DataTypes::Bool'
-                EditBool
-            else
-                Edit
-            end
-            w = wclass.new(@request, @response, @scene)
+            w = Edit.new(@request, @response, @scene)
             w.attributes[:name] = key
             w.attributes[:option] = option
             w.widget_init

data/apps/core/components/widgets/table/table.rb

@@ -95,7 +95,7 @@ module Spider; module Components
             end
             @rows = prepare_queryset(@queryset ? @queryset : @model.list)
             @rows.condition.and(self.condition) if self.condition && !self.condition.empty?
-            if (@attributes[:paginate])
+            if @attributes[:paginate]
                 @rows.limit = @attributes[:row_limit]
                 @rows.offset = @offset
                 @scene.page = @page
@@ -111,8 +111,10 @@ module Spider; module Components
             @scene.rows = prepare_rows(@rows)
             @scene.data = @rows
             @scene.has_more = @rows.has_more?
-            @scene.pages = (@rows.total_rows.to_f / @attributes[:row_limit]).ceil
-            @scene.paginate_last = [@scene.paginate_first + 9, @scene.pages].min
+            if @attributes[:paginate]
+                @scene.pages = (@rows.total_rows.to_f / @attributes[:row_limit]).ceil
+                @scene.paginate_last = [@scene.paginate_first + 9, @scene.pages].min
+            end
             @scene.columns = @elements.size
             super
         end

data/apps/core/forms/widgets/form/form.rb

@@ -315,7 +315,9 @@ module Spider; module Forms
         end
         
         def load
-            instantiate_obj if (@pk)
+            obj = instantiate_obj if (@pk)
+            trigger(:after_load, obj)
+            obj
         end
         
         def save(action=nil)

data/lib/spiderfw/config/options/spider.rb

@@ -181,8 +181,7 @@ module Spider
         :do => lambda{ |val| ENV['http_proxy'] = val }
         
     config_option 'resources.disable_custom', _("Disable resource overriding in home"), :type => Spider::Bool, :default => false
-    
-    config_option 'migrations.window', _("Fetch window to use when migrating models"), :type => Fixnum, :default => 100
+
     
     
 end

data/lib/spiderfw/model/condition.rb

@@ -250,15 +250,15 @@ module Spider; module Model
                 cnt += 1
                 comparison = @comparisons[key] || '='
                 cond = "#{comparison} #{value.inspect}"
-                str += "#{key} #{cond}"
+                str += "#{key.inspect} #{cond}"
             end
-            str = '(' + str + ')' if str.length > 0
             #str += ' [raw:'+raw.inspect+']' unless raw.empty?
             first = true
             if @subconditions.length > 0
                 str += ' '+@conjunction.to_s+' ' if str.length > 0
-                str += @subconditions.map{ |sub| sub.inspect }.join(' '+@conjunction.to_s+' ')
+                str += @subconditions.map{ |sub| sub.inspect }.reject{ |sub| sub.empty? }.join(' '+@conjunction.to_s+' ')
             end
+            str = "(#{str})" if cnt + @subconditions.length > 1
             return str
         end
         

data/lib/spiderfw/model/mappers/db_mapper.rb

@@ -494,7 +494,13 @@ module Spider; module Model; module Mappers
             cond[:values] = []
             
 
-            # Returns an hash of elements that need an "inner" join
+            # Returns an hash with true for elements that need an inner join
+            # Note: subsequent joins of a left join  have to be left joins, 
+            # otherwise the first join will behave as an inner.
+            # Maybe they should be marked and later made behave like an inner with an
+            # appropriate (A.key is null or B.key is not null) condition.
+            # Not sure if this is needed, since first level conditions should filter out
+            # any unwanted results.
             def get_join_info(model, condition)
                 join_info = {}
                 condition.each_with_comparison do |k, v, comp|
@@ -524,21 +530,27 @@ module Spider; module Model; module Mappers
                         end
                     end
                 end
-                sub = {}
+                res = {}
+                keys = join_info.keys
+                sub_join_infos = [join_info]
                 condition.subconditions.each do |sub_cond|
                     next if sub_cond.empty?
                     sub_join_info = get_join_info(model, sub_cond)
-                    sub_join_info.each_key do |k|
+                    keys += sub_join_info.keys
+                    sub_join_infos << sub_join_info
+                end
+                keys.uniq!
+                sub_join_infos.each do |sub_join_info|
+                    keys.each do |k|
                         if condition.conjunction == :or
-                            sub[k] = true if sub_join_info[k] && sub[k] != false
-                            sub[k] = false unless sub_join_info
+                            res[k] = true if sub_join_info[k] && res[k] != false
+                            res[k] = false unless sub_join_info[k]
                         else
-                            sub[k] = true if sub_join_info[k]
+                            res[k] = true if sub_join_info[k]
                         end
                     end
                 end
-                join_info.merge!(sub)
-                join_info
+                res
             end
 
             
@@ -546,12 +558,32 @@ module Spider; module Model; module Mappers
             join_info = options[:join_info]
             join_info ||= get_join_info(@model, condition)
 
+            def has_aggregates?(condition, in_or=false)
+                condition.each_with_comparison do |k, v, comp|
+                    return true if k.is_a?(QueryFuncs::Function) && k.has_aggregates?
+                end
+                in_or = true if condition.conjunction == :or
+                condition.subconditions.each do |sub_cond|
+                    return true if in_or && has_aggregates?(sub_cond, in_or)
+                end
+                return false
+            end
+
+            is_having = options[:is_having]
+            is_having = has_aggregates?(condition) if is_having.nil?
+
+            cond[:group_by_fields] ||= [] if is_having
 
             condition.each_with_comparison do |k, v, comp|
                 if k.is_a?(QueryFuncs::Function)
                     field = prepare_queryfunc(k)
                     cond[:values] << [field, comp, v]
                     joins += field.joins
+                    if is_having
+                        cond[:group_by_fields] += k.inner_elements.map{ |el_name, owner_func| 
+                            owner_func.mapper_fields[el_name.to_s]
+                        }
+                    end
                     next
                 end
                 element = model.elements[k.to_sym]
@@ -566,13 +598,14 @@ module Spider; module Model; module Mappers
                     if (v && model.mapper.have_references?(element.name) && v.select{ |key, value| 
                         !element.model.elements[key] || !element.model.elements[key].primary_key? }.empty?)
                         # 1/n <-> 1 with only primary keys
-                        element_cond = {:conj => 'AND', :values => []}
+                        element_cond = {:conj => 'AND', :values => [], :is_having => is_having}
                         v.each_with_comparison do |el_k, el_v, el_comp|
-                            field = model_schema.qualified_foreign_key_field(element.name, el_k)
+                            field = model_schema.foreign_key_field(element.name, el_k)
                             el_comp ||= '='
                             op = el_comp
                             field_cond = [field, op,  map_condition_value(element.model.elements[el_k.to_sym].type, el_v)]
                             element_cond[:values] << field_cond
+                            cond[:group_by_fields] << field if is_having
                         end
                         cond[:values] << element_cond
                     else
@@ -599,23 +632,30 @@ module Spider; module Model; module Mappers
                             
                             if v.nil? && comp == '='
                                 el_model_schema = model_schema
-                                element_cond = {:conj => 'AND', :values => []}
-                                    if model.mapper.have_references?(element.name)
+                                element_cond = {:conj => 'AND', :values => [], :is_having => is_having}
+                                if model.mapper.have_references?(element.name)
                                     el_name = element.name
                                     el_model = element.model
-                                else
+                                elsif element.junction?
                                     el_model = element.type
                                     el_model_schema = element.model.mapper.schema 
-                                    el_name = element.attributes[:junction_their_element]
+                                    el_name = element.attributes[:junction_their_element]    
+                                else
+                                    el_model = element.type
+                                    el_model_schema = el_model.mapper.schema
+                                    el_name = element.reverse
                                 end
                                 el_model.primary_keys.each do |k|
-                                    field = el_model_schema.qualified_foreign_key_field(el_name, k.name)
+                                    field = el_model_schema.foreign_key_field(el_name, k.name)
                                     field_cond = [field, comp,  map_condition_value(element.model.elements[k.name].type, nil)]
                                     element_cond[:values] << field_cond
+                                    element_cond[:is_having] = is_having
+                                    cond[:group_by_fields] << field if is_having
                                 end
                                 cond[:values] << element_cond
                             elsif v
-                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :joins => joins, :join_info => el_join_info)
+                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], 
+                                    :joins => joins, :join_info => el_join_info, :is_having => is_having || nil)
                                 sub_condition[:table] = sub_join[:as] if sub_join[:as]
                                 joins = sub_joins
                                 cond[:values] << sub_condition
@@ -627,7 +667,8 @@ module Spider; module Model; module Mappers
                         end
                     end
                 elsif(model_schema.field(element.name))
-                    field = model_schema.qualified_field(element.name, options[:table])
+                    field = model_schema.field(element.name)
+                    field = FieldInAliasedTable(field, options[:table]) if options[:table]
                     op = comp ? comp : '='
                     if (v.is_a?(Spider::QueryFuncs::Expression))
                         v_joins = prepare_expression(v)
@@ -636,13 +677,16 @@ module Spider; module Model; module Mappers
                     else
                         cond[:values] << [field, op, map_condition_value(model.elements[k.to_sym].type, v)]
                     end
+                    cond[:group_by_fields] << field if is_having
                 end
-                
+
             end
+            cond[:is_having] = is_having
+
             sub_sqls = []
             sub_bind_values = []
             condition.subconditions.each do |sub|
-                sub_res = self.prepare_condition(sub, :joins => joins, :join_info => join_info)
+                sub_res = self.prepare_condition(sub, :joins => joins, :join_info => join_info, :is_having => is_having || nil)
                 cond[:values] << sub_res[0]
                 joins = sub_res[1]
                 remaining_condition += sub_res[2]
@@ -766,9 +810,11 @@ module Spider; module Model; module Mappers
                 el_joins, el_model, el = get_deep_join(el_name)
                 joins += el_joins
                 owner_func.mapper_fields ||= {}
-                owner_func.mapper_fields[el.name] = el_model.mapper.schema.field(el.name)
+                owner_func.mapper_fields[el_name.to_s] = el_model.mapper.schema.field(el.name)
             end
-            return FieldFunction.new(storage.function(func), schema.table, joins)
+            f = FieldFunction.new(storage.function(func), schema.table, joins)
+            f.aggregate = true if func.has_aggregates?
+            return f
         end
         
         # Takes a Spider::QueryFuncs::Expression, and associates the fields to the corresponding elements

data/lib/spiderfw/model/mappers/mapper.rb

@@ -442,7 +442,8 @@ module Spider; module Model
             preprocess_condition(condition)
             cascade = @model.elements_array.select{ |el| !el.integrated? && el.attributes[:delete_cascade] }
             assocs = association_elements.select do |el|
-                !storage.supports?(:delete_cascade) || !schema.cascade?(el.name) # TODO: implement
+                !el.junction? && # done later from @model.referenced_by_junctions
+                (!storage.supports?(:delete_cascade) || !schema.cascade?(el.name)) # TODO: implement
             end
             curr = @model.where(condition) unless curr
             before_delete(curr)
@@ -950,7 +951,9 @@ module Spider; module Model
                         condition.delete(k)
                         integrated_from = element.integrated_from
                         integrated_from_element = element.integrated_from_element
-                        condition.set("#{integrated_from.name}.#{integrated_from_element}", c, v)
+                        sub = condition.get_deep_obj
+                        sub.set(integrated_from_element, c, v)
+                        condition[integrated_from.name] = integrated_from.model.mapper.preprocess_condition(sub) 
                     elsif element.junction? && !v.is_a?(BaseModel) && !v.is_a?(Hash) && !v.nil? # conditions on junction id don't make sense
                         condition.delete(k)
                         condition.set("#{k}.#{element.attributes[:junction_their_element]}", c, v)

data/lib/spiderfw/model/mixins/versioned.rb

@@ -112,6 +112,9 @@ module Spider; module Model
                           vmod.elements[el.name].attributes.delete(:condition)
                       end
                       if el.multiple? && !el.attributes[:junction] && !is_version_content
+                          # Note: this creates a junction
+                          # When the object is deleted, the junction will be deleted too since the object
+                          # is not versioned
                           elh[:attributes].delete(:reverse)
                           elh[:attributes].delete(:add_reverse)
                           elh[:attributes].delete(:add_multiple_reverse)

data/lib/spiderfw/model/query_funcs.rb

@@ -78,6 +78,22 @@ module Spider; module QueryFuncs
             return els
         end
 
+        def aggregate?
+            false
+        end
+
+        def has_aggregates?
+            return true if aggregate?
+            elements.each do |el|
+                return true if el.is_a?(Function) && el.has_aggregates?
+            end
+            return false
+        end
+
+        def inspect
+            "#{self.func_name.to_s.upcase}(#{elements.map{ |el| el.inspect }.join(', ')})"
+        end
+
     end
 
     class ZeroArityFunction < Function
@@ -133,6 +149,11 @@ module Spider; module QueryFuncs
     end
 
     class Subtract < BinaryFunction
+
+        def inspect
+            "#{@el1.inspect} - #{@el2.inspect}"
+        end
+
     end
     
     class Concat < NAryFunction
@@ -149,5 +170,35 @@ module Spider; module QueryFuncs
         
     end
 
+    class AggregateFunction < UnaryFunction
+
+        def aggregate?
+            true
+        end
+
+    end
+
+
+    class Avg < AggregateFunction
+    end
+
+    class Count < AggregateFunction
+    end
+
+    class First < AggregateFunction
+    end
+
+    class Last < AggregateFunction
+    end
+
+    class Max < AggregateFunction
+    end
+
+    class Min < AggregateFunction
+    end
+
+    class Sum < AggregateFunction
+    end
+
 
 end; end

data/lib/spiderfw/model/storage/db/adapters/oracle.rb

@@ -140,11 +140,28 @@ module Spider; module Model; module Storage; module Db
              end
              keys = sql_keys(query)
              tables_sql, tables_values = sql_tables(query)
+
              sql = "SELECT #{keys} FROM #{tables_sql} "
              bind_vars += tables_values
+
              where, vals = sql_condition(query)
              bind_vars += vals
              sql += "WHERE #{where} " if where && !where.empty?
+
+             having, having_vals = sql_condition(query, true)
+             unless having.blank?
+                unless (query[:limit] || query[:query_type] == :count) && !query[:joins].empty?
+
+                    group_fields = (
+                        query[:keys].select{ |k| !k.is_a?(FieldExpression)
+                    } + collect_having_fields(query[:condition])).flatten.uniq
+                    group_keys = sql_keys(group_fields)
+                    sql += "GROUP BY #{group_keys} "
+                    sql += "HAVING #{having} "
+                end
+                bind_vars += having_vals
+             end
+
              order = sql_order(query, query[:order_replacements])
              if (query[:limit] || query[:query_type] == :count)
                  limit = nil
@@ -158,9 +175,16 @@ module Spider; module Model; module Storage; module Db
                  end
                  if (!query[:joins].empty?)
                      data_tables_sql = query[:order_on_different_table] ? tables_sql : query[:tables].join(', ')
-                     pk_sql = query[:primary_keys].reject{ |pk| pk.is_a?(Db::FieldExpression) }.join(', ')
+                     pks = query[:primary_keys].reject{ |pk| pk.is_a?(Db::FieldExpression) }
+                     pk_sql = pks.join(', ')
                      distinct_sql = "SELECT DISTINCT #{pk_sql} FROM #{tables_sql}"
-                     distinct_sql += " WHERE #{where}" if where && !where.empty?
+                     distinct_sql += " WHERE #{where}" unless where.blank?
+                     unless having.blank?
+
+                        group_keys = sql_keys((pks + collect_having_fields(query[:condition])).flatten.uniq)
+                        distinct_sql += " GROUP BY #{group_keys} "
+                        distinct_sql += " HAVING #{having}"
+                     end
                      data_sql = "SELECT #{keys} FROM #{data_tables_sql} WHERE (#{pk_sql}) IN (#{distinct_sql})"
                      data_sql += " order by #{order}" unless order.blank?
                  else
@@ -185,6 +209,7 @@ module Spider; module Model; module Storage; module Db
          
          def sql_condition_value(key, comp, value, bound_vars=true)
              curr[:bind_cnt] ||= 0
+             key = key.expression if key.is_a?(FieldExpression)
              if (comp.to_s.downcase == 'ilike')
                  comp = 'like'
                  key = "UPPER(#{key})"

data/lib/spiderfw/model/storage/db/connectors/oci8.rb

@@ -100,9 +100,9 @@ module Spider; module Model; module Storage; module Db; module Connectors
                 bind_vars.each_index do |i|
                     var = bind_vars[i]
                     if (var.is_a?(Oracle::OracleNilValue))
-                        cursor.bind_param(i+1, nil, var.type, 0)
+                        cursor.bind_param(":#{i+1}", nil, var.type, 0)
                     else
-                        cursor.bind_param(i+1, var)
+                        cursor.bind_param(":#{i+1}", var)
                     end
                 end
                 res = cursor.exec

data/lib/spiderfw/model/storage/db/db_schema.rb

@@ -97,6 +97,7 @@ module Spider; module Model; module Storage; module Db
         
         # Sets the column name for an element.
         def set_column(element_name, field)
+            field = {:name => field} if field.is_a?(String)
             field = Field.new(@table, field[:name], field[:type], field[:attributes] || {}) if field.is_a?(Hash)
             had_column = @columns[element_name]
             @columns[element_name] = field
@@ -105,6 +106,7 @@ module Spider; module Model; module Storage; module Db
         
         # Sets a foreign key to the primary key of an element.
         def set_foreign_key(element_name, element_key, field)
+            field = {:name => field} if field.is_a?(String)
             if field.is_a?(Hash)
                 field[:attributes] ||= {}
                 field[:attributes][:expression] ||= field[:expression]
@@ -241,6 +243,25 @@ module Spider; module Model; module Storage; module Db
         end
         
     end
+
+    class FieldInAliasedTable < Field
+
+        def initialize(field, table_alias)
+            @table = field.table
+            @name = field.name
+            @type = field.type
+            @table_alias = table_alias
+        end
+
+        def to_s
+            "#{@table_alias}.#{@name}"
+        end
+
+        def inspect
+            "#<#{self.class.name}:#{self.object_id} @name=\"#{@name}\", @table=#<Spider::Model::Storage::Db::Table:#{@table.object_id} #{@table.name} AS #{@table_alias}> >"
+        end
+
+    end
     
     class FieldExpression < Field
         attr_reader :expression
@@ -264,6 +285,14 @@ module Spider; module Model; module Storage; module Db
             @table = table
             @joins = joins
         end
+
+        def aggregate=(val)
+            @aggregate = val
+        end
+
+        def aggregate?
+            !!@aggregate
+        end
         
         def to_s
             @expression

data/lib/spiderfw/model/storage/db/db_storage.rb

@@ -165,7 +165,7 @@ module Spider; module Model; module Storage; module Db
                 if (func_el.is_a?(Spider::QueryFuncs::Function))
                     function(func_el)
                 else
-                    func.mapper_fields[func_el]
+                    func.mapper_fields[func_el.to_s]
                 end
             }
             case func.func_name
@@ -183,6 +183,8 @@ module Spider; module Model; module Storage; module Db
                 return "(#{fields[0]} - #{fields[1]})"
             when :rownum
                 return "ROWNUM()"
+            when :sum, :avg, :count, :first, :last, :max, :min
+                return "#{func.func_name.to_s.upcase}(#{fields[0]})"
             end
             raise NotImplementedError, "#{self.class} does not support function #{func.func_name}"
         end
@@ -249,6 +251,16 @@ module Spider; module Model; module Storage; module Db
             where, vals = sql_condition(query)
             bind_vars += vals
             sql += "WHERE #{where} " if where && !where.empty?
+            having, having_vals = sql_condition(query, true)
+            unless having.blank?
+                group_fields = (
+                    query[:keys].select{ |k| !k.is_a?(FieldExpression)
+                } + collect_having_fields(query[:condition])).flatten.uniq
+                group_keys = sql_keys(group_fields)
+                sql += "GROUP BY #{group_keys} "
+                sql += "HAVING #{having} "
+                bind_vars += having_vals
+            end
             order = sql_order(query)
             sql += "ORDER BY #{order} " if order && !order.empty?
             limit = sql_limit(query)
@@ -262,6 +274,7 @@ module Spider; module Model; module Storage; module Db
         
         # Returns the SQL for select keys.
         def sql_keys(query)
+            query = {:keys => query} unless query.is_a?(Hash)
             query[:keys].join(',')
         end
         
@@ -300,39 +313,45 @@ module Spider; module Model; module Storage; module Db
         end
         
         # Returns SQL and bound variables for a condition.
-        def sql_condition(query)
+        def sql_condition(query, having=false)
             condition = query[:condition]
             return ['', []] unless (condition && condition[:values])
             bind_vars = []
-            condition[:values].reject!{ |v| v.is_a?(Hash) && v[:values].empty? }
-            mapped = condition[:values].map do |v|
-                if (v.is_a? Hash) # subconditions
+            condition[:values].reject!{ |v| (v.is_a?(Hash) && v[:values].empty?)}
+            vals = condition[:values]
+
+            return nil if !having && condition[:is_having]
+            mapped = vals.map do |v|
+                if v.is_a? Hash # subconditions
                     # FIXME: optimize removing recursion
-                    
-                    sql, vals = sql_condition({:condition => v})
+                    sql, vals = sql_condition({:condition => v}, having)
+                    next unless sql
                     bind_vars += vals
                     sql = nil if sql.empty?
                     sql = "(#{sql})" if sql && v[:values].length > 1
                     sql
-                elsif (v[2].is_a? Spider::QueryFuncs::Expression)
-                    sql_condition_value(v[0], v[1], v[2].to_s, false)
-                else
-                    v[1] = 'between' if (v[2].is_a?(Range))
-                    v[2].upcase! if (v[1].to_s.downcase == 'ilike')
-                    if (v[1].to_s.downcase == 'between')
-                        bind_vars << v[2].first
-                        bind_vars << v[2].last
+                elsif !having || condition[:is_having]
+                    if v[2].is_a? Spider::QueryFuncs::Expression
+                        sql_condition_value(v[0], v[1], v[2].to_s, false)
                     else
-                        bind_vars << v[2] unless v[2].nil?
+                        v[1] = 'between' if (v[2].is_a?(Range))
+                        v[2].upcase! if (v[1].to_s.downcase == 'ilike')
+                        if (v[1].to_s.downcase == 'between')
+                            bind_vars << v[2].first
+                            bind_vars << v[2].last
+                        else
+                            bind_vars << v[2] unless v[2].nil?
+                        end
+                        sql_condition_value(v[0], v[1], v[2])
                     end
-                    sql_condition_value(v[0], v[1], v[2])
                 end
             end
-            return mapped.select{ |p| p != nil}.join(' '+(condition[:conj] || 'and')+' '), bind_vars
+            return mapped.reject{ |p| p.nil? }.join(' '+(condition[:conj] || 'and')+' '), bind_vars
         end
         
         # Returns the SQL for a condition comparison.
         def sql_condition_value(key, comp, value, bound_vars=true)
+            key = key.expression if key.is_a?(FieldExpression)
             if (comp.to_s.downcase == 'ilike')
                 comp = 'like'
                 key = "UPPER(#{key})"
@@ -709,6 +728,12 @@ module Spider; module Model; module Storage; module Db
             end
             return sql, values
         end
+
+        def collect_having_fields(condition)
+            c = condition
+            c.is_a?(Hash) ? 
+                ((c[:group_by_fields] || []) + (c[:values] || []).map{ |v| collect_having_fields(v) }) : []
+        end
         
         ##############################################################
         #   Reflection                                               #

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: spiderfw
 version: !ruby/object:Gem::Version 
-  hash: 33
+  hash: 47
   prerelease: 
   segments: 
   - 0
   - 6
-  - 19
-  version: 0.6.19
+  - 20
+  version: 0.6.20
 platform: ruby
 authors: 
 - Ivan Pirlik
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-21 00:00:00 +02:00
+date: 2011-10-05 00:00:00 +02:00
 default_executable: spider
 dependencies: 
 - !ruby/object:Gem::Dependency