rquerypad 0.1.20 → 0.1.21

data/CHANGELOG

@@ -1,3 +1,6 @@
+Changes in version 0.1.21 (2009-4-14)
+rquerypad will not change original options to avoid side effect
+
 Changes in version 0.1.20 (2009-3-9)
 ------------------------------------
 Support rails 2.3

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 
 PKG_NAME = "rquerypad"
-PKG_VERSION = "0.1.20"
+PKG_VERSION = "0.1.21"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_FILES = FileList[
   '[A-Z]*',

data/lib/rquerypad.rb

@@ -3,15 +3,15 @@ author: Leon Li(scorpio_leon@hotmail.com)
 =end
 require 'md5'
 class Rquerypad
-  class << self
+    class << self
     
-    def prepare_with_debug
-      prepare(true)
-    end
-    def prepare(debug = $RQUERYPAD_DEBUG)
-      return nil unless @prepared.nil?
-      @prepared = true
-      ActiveRecord::Base.class_eval %{
+        def prepare_with_debug
+            prepare(true)
+        end
+        def prepare(debug = $RQUERYPAD_DEBUG)
+            return nil unless @prepared.nil?
+            @prepared = true
+            ActiveRecord::Base.class_eval %{
         class << self
         def group_tables(options)
           group = [options[:group], scope(:find, :group) ].join(", ")
@@ -25,8 +25,8 @@ class Rquerypad
           include_eager_order?(options) || include_eager_conditions?(options) || include_eager_select?(options) || include_eager_group?(options)
         end
         end
-      }
-      ActiveRecord::Base.class_eval %{
+            }
+            ActiveRecord::Base.class_eval %{
         require "rquerypad"
         
         class << self
@@ -44,7 +44,7 @@ class Rquerypad
               #p "rquerypad_cache[cache_key]: #\{rquerypad_cache[cache_key]\}"
 	            if rquerypad_cache[cache_key].nil?
 	              #{"p 'process for:', options" if debug}
-                Rquerypad.new(self).improve_options!(options)
+                options = Rquerypad.new(self).improve_options!(options)
                 rquerypad_cache[cache_key] = Marshal.dump(options)
                 #p "rquerypad_cache[cache_key]: #\{rquerypad_cache[cache_key]\}"
               else
@@ -66,9 +66,9 @@ class Rquerypad
             @@rquerypad_cache
           end
         end
-      }
+            }
       
-      ActiveRecord::Calculations.class_eval %{
+            ActiveRecord::Calculations.class_eval %{
         require "rquerypad"
         module ClassMethods
           @@rquerypad_cache = {}
@@ -80,7 +80,7 @@ class Rquerypad
               cache_key = Rquerypad.options_key(self, options)
               if rquerypad_cache[cache_key].nil?
                 #{"p 'process for:', options" if debug}
-                Rquerypad.new(self).improve_options!(options)
+                options = Rquerypad.new(self).improve_options!(options)
                 rquerypad_cache[cache_key] = Marshal.dump(options)
               else
                 options = Marshal.load(rquerypad_cache[cache_key])
@@ -97,251 +97,269 @@ class Rquerypad
             @@rquerypad_cache
           end
         end
-      }
+            }
       
-      Hash.class_eval do
-        def single_lt?(other)
-          return false if self == other
-          return true if self.size == 0
-          return false unless other.is_a?(Hash)
-          return false if other.nil? || other.size < self.size
-          return false if self.size != other.size || self.size > 1 
-          a = self.to_a[0]
-          o = other.to_a[0]
-          return false if a[0] != o[0]
-          return true unless a[1].is_a?(Hash)
-          a[1].single_lt?(o[1]) 
+            Hash.class_eval do
+                def single_lt?(other)
+                    return false if self == other
+                    return true if self.size == 0
+                    return false unless other.is_a?(Hash)
+                    return false if other.nil? || other.size < self.size
+                    return false if self.size != other.size || self.size > 1
+                    a = self.to_a[0]
+                    o = other.to_a[0]
+                    return false if a[0] != o[0]
+                    return true unless a[1].is_a?(Hash)
+                    a[1].single_lt?(o[1])
+                end
+                def single_gt?(other)
+                    return false if self == other
+                    return !(single_lt?(other))
+                end
+            end
         end
-        def single_gt?(other)
-          return false if self == other
-          return !(single_lt?(other))
+    
+        def process_inner_join(sql, inner_joins)
+            inner_joins.each {|i| sql.gsub!(/LEFT OUTER JOIN [`]?#{i}[`]?/, "INNER JOIN #{i}")} unless inner_joins.empty?
+            sql
         end
-      end
-    end
     
-    def process_inner_join(sql, inner_joins)
-      inner_joins.each {|i| sql.gsub!(/LEFT OUTER JOIN [`]?#{i}[`]?/, "INNER JOIN #{i}")} unless inner_joins.empty?
-      sql
+        def options_key(obj, options)
+            key = obj.to_s + options.to_a.to_s
+            key = MD5.hexdigest(key) if key.length > 100
+            key
+        end
     end
-    
-    def options_key(obj, options)
-      key = obj.to_s + options.to_a.to_s
-      key = MD5.hexdigest(key) if key.length > 100
-      key
+    def initialize(obj)
+        @owner = obj
+        @class_name = obj.to_s.scan(/(\w*::)*([^\(]*)/)[0][1]
+        # #@table_name = @class_name.pluralize.underscore
+        @table_name = obj.table_name
+        @tnwithdot = @table_name + "."
+        @new_include = []
+        @old_include = nil
+        @inner_joins = []
     end
-  end
-  def initialize(obj)
-    @owner = obj
-    @class_name = obj.to_s.scan(/(\w*::)*([^\(]*)/)[0][1]
-    #@table_name = @class_name.pluralize.underscore
-	 @table_name = obj.table_name 
-    @tnwithdot = @table_name + "."
-    @new_include = []
-    @old_include = nil
-    @inner_joins = []
-  end
   
-  def improve_options!(option_hash)
-    
-    option_hash.each do |key, value|
-      next if value.blank?
-      key_str = key.to_s
-      if key_str == "conditions"
-        option_hash[key] = improve_conditions(value)
-      elsif (key_str == "order" || key_str == "group" || key_str == "group_field")
-        option_hash[key] = improve_ordergroup(value).join(", ")
-      elsif (key_str == "include")
-        @old_include = value
-      end
-    end
-    return nil if @new_include.empty? 
-    #generate new include
+    def improve_options!(option_hash)
+        new_options = {}
+        option_hash.each do |key, value|
+            if value.blank?
+                new_options[key] = value
+                next
+            end
+            key_str = key.to_s
+            if key_str == "conditions"
+                new_options[key] = improve_conditions(value)
+            elsif (key_str == "order" || key_str == "group" || key_str == "group_field")
+                new_options[key] = improve_ordergroup(value).join(", ")
+            else
+                new_options[key] = value
+                if (key_str == "include")
+                    @old_include = value
+                end
+            end
+        end
+        return new_options if @new_include.empty?
+        # #generate new include
     
-    remove_dup_includes
-    unless @new_include.nil?
-      option_hash[:include] = [] if @old_include.nil?
-      @new_include += @old_include unless @old_include.nil?
-      option_hash.each do |key, value|
-        if key.to_s == "include"
-          option_hash[key] = @new_include
+        remove_dup_includes
+        unless @new_include.nil?
+            new_options[:include] ||= []
+            new_options[:include]  += @new_include
+            new_options[:include].uniq!
         end
-      end
+        new_options[:inner_joins] = @inner_joins unless @inner_joins.empty?
+        new_options
     end
-    option_hash[:inner_joins] = @inner_joins unless @inner_joins.empty? 
-  end
   
-  def remove_dup_includes
-    final_includes = []
-    @new_include.each do |ni|
-      next if final_includes.include?(ni)
-      if final_includes.size > 0
-        final_includes.each_index do |i|
-          if ni.is_a?(Hash)
-            if final_includes[i].is_a?(Hash)
-              if final_includes[i].single_lt?(ni)
-                final_includes[i] = ni 
-              elsif final_includes[i].single_gt?(ni)
-              else
-                final_includes << ni
-              end
-            elsif ni.entries[0][0].to_s == final_includes[i].to_s
-              final_includes[i] = ni
+    def remove_dup_includes
+        final_includes = []
+        @new_include.each do |ni|
+            next if final_includes.include?(ni)
+            if final_includes.size > 0
+                final_includes.each_index do |i|
+                    if ni.is_a?(Hash)
+                        if final_includes[i].is_a?(Hash)
+                            if final_includes[i].single_lt?(ni)
+                                final_includes[i] = ni
+                            elsif final_includes[i].single_gt?(ni)
+                            else
+                                final_includes << ni
+                            end
+                        elsif ni.entries[0][0].to_s == final_includes[i].to_s
+                            final_includes[i] = ni
+                        else
+                            final_includes << ni
+                        end
+                    else
+                        if final_includes[i].is_a?(Hash)
+                            final_includes << ni if final_includes[i].entries[0][0].to_s != ni.to_s
+                        else
+                            final_includes << ni if final_includes[i].to_s != ni.to_s
+                        end
+                    end
+                end
             else
-              final_includes << ni
-            end
-          else
-            if final_includes[i].is_a?(Hash)
-              final_includes << ni if final_includes[i].entries[0][0].to_s != ni.to_s
-            else
-              final_includes << ni if final_includes[i].to_s != ni.to_s
+                final_includes << ni
             end
-          end
         end
-      else
-        final_includes << ni
-      end
+        @new_include = final_includes
     end
-    @new_include = final_includes
-  end
   
-  def improve_conditions(options)
-
-    if options.is_a?(Hash)
-      #work around frozen issue
-      new_options = {}
-      until options.empty?
-        key, value = options.shift
-        key = key.to_s.dup
-        new_options[process_single!(key)] = value
-      end
-      options.merge!(new_options)
-    else
-      if options.is_a?(String)
-        options = [options]
-      end
-      str = options[0]
-      return nil if str.nil?
-      qp = /['"][^."]*['"]/
-      temp = str.scan(qp)
-      #replace string in quote to avoid unecessary processing
-      str.gsub!(qp, "'[??]'") unless temp.empty?
-      str.gsub!(/(([\w\(\)]+\.)+\w+)[ !><=]/) do |n|
-        #cut last char and abstract association for include
-        if n =~ /^\(/
-          '(' + abstract_association(n[1..-2]) + n[-1, 1]
+    def improve_conditions(options)
+        new_options = nil
+        if options.is_a?(Hash)
+            # #work around frozen issue
+            new_options = {}
+            until options.empty?
+                key, value = options.shift
+                new_options[process_single(key.to_s)] = value
+            end
         else
-          abstract_association(n[0..-2]) + n[-1, 1]
-        end
+            if options.is_a?(String)
+                new_options = [options]
+            else
+                new_options = options.dup
+            end
+            str = new_options[0]
+            return nil if str.nil?
+            qp = /['"][^."]*['"]/
+            temp = str.scan(qp)
+            # #replace string in quote to avoid unecessary processing
+            str = str.gsub(qp, "'[??]'") unless temp.empty?
+            str = str.gsub(/(([\w\(\)]+\.)+\w+)[ !><=]/) do |n|
+                # #cut last char and abstract association for include
+                if n =~ /^\(/
+                    '(' + abstract_association(n[1..-2]) + n[-1, 1]
+                else
+                    abstract_association(n[0..-2]) + n[-1, 1]
+                end
         
-      end
-      #add @table_name on single field
-      str.gsub!(/[\.:]?[`"']?\w+[`"']?[\.]?/) {|x| (x =~ /\D+/).nil? || x[-1, 1] == "." || x[0, 1] == ":" || ["and", "or", "is", "null", "not", "like", "in"].include?(x.downcase) ? x : @tnwithdot + x}
-      str.gsub!(/\.#{@table_name}\./, ".")
-      #recover string in quote
-      unless temp.empty?
-        i = -1
-        str.gsub!(/\'\[\?\?\]\'/) do
-          i += 1
-          temp[i]
+            end
+            # #add @table_name on single field
+            str = str.gsub(/[\.:]?[`"']?\w+[`"']?[\.]?/) {|x| (x =~ /\D+/).nil? || x[-1, 1] == "." || x[0, 1] == ":" || ["and", "or", "is", "null", "not", "like", "in"].include?(x.downcase) ? x : @tnwithdot + x}
+            str = str.gsub(/\.#{@table_name}\./, ".")
+            # #recover string in quote
+            unless temp.empty?
+                i = -1
+                str = str.gsub(/\'\[\?\?\]\'/) do
+                    i += 1
+                    temp[i]
+                end
+            end
+            new_options[0] = str
         end
-      end
-      options[0] = str
+        new_options
     end
-    options
-  end
   
-  def process_single!(key)
-    return key.sub!('=', '') if key[0, 1] == '='
-    if key.include?(".")
-      if /^(.+)[ ]/ =~ key
-        key.sub!("#$1", abstract_association("#$1"))
-      else
-        key.sub!(/^.+$/, abstract_association(key))
-      end
-    else
-      key.sub!(/^.+$/, @tnwithdot + key)
+    def process_single(key)
+        return key.sub('=', '') if key[0, 1] == '='
+        if key.include?(".")
+            if /^(.+)[ ]/ =~ key
+                key = key.sub("#$1", abstract_association("#$1"))
+            else
+                key = key.sub(/^.+$/, abstract_association(key))
+            end
+        else
+            key = key.sub(/^.+$/, @tnwithdot + key)
+        end
+        key
     end
-  end
   
-  def improve_ordergroup(fields)
-    fields = [fields] if fields.is_a?(String)
-    fields.each {|field| process_single!(field)}
-    fields
-  end
-  
-  def abstract_association(str)
-    result = nil
-    owner = @owner
-    names = str.split(".")
-    return str if names.size == 2 && names[0] == @table_name
-    #seperate assocations/tables and field
-    tables, field = names[0..-2], names[-1]
-    owners = []
-    #get relevant owner for each table
-    tables.each_index do |i|
-      #tables[i] = tables[i].pluralize
-      if i == 0
-        owners[i] = owner
-      else
-        tname = cut_end_underscore(tables[i-1])
-        r = owners[i-1].reflections[tname.to_sym].options
-        owners[i] = r[:class_name].nil? ? eval(owners[i-1].to_s.gsub(/\w*$/, "")+tname.singularize.camelize) : eval("#{r[:class_name]}")
-      end
-    end
-    owners.reverse!
-    tables.reverse!
-    tables.each_index do |i|
-      if tables[i][-1, 1] == "_"
-        tables[i].reverse!.sub!("_", "").reverse!
-        @inner_joins << transfer_table_name(tables[i], owners[i])
-      end
-    end
-    #process special id field in a belongs_to association
-    if field == "id" 
-      if owners[0].reflections[tables[0].to_sym].macro.to_s == "belongs_to"
-        result = transfer_table_id(tables[0], owners[0])
-        @inner_joins.delete(tables[0]) if @inner_joins.include?(tables[0])
-        unless owners[1].nil?
-          result = transfer_table_name(tables[1], owners[1]) + "." + result
+    def improve_ordergroup(fields)
+        result = []
+        if fields.is_a?(Array)
+            result += fields 
+        else
+            result << fields
         end
-        tables.delete_at(0)
-        owners.delete_at(0)
-        return result if tables.empty?
-      end
+        result.each_index {|i| result[i] = process_single(result[i])}
+        result
     end
+  
+    def abstract_association(str)
+        result = nil
+        owner = @owner
+        names = str.split(".")
+        return str if names.size == 2 && names[0] == @table_name
+        # #seperate assocations/tables and field
+        tables, field = names[0..-2], names[-1]
+        owners = []
+        # #get relevant owner for each table
+        tables.each_index do |i|
+            # #tables[i] = tables[i].pluralize
+            if i == 0
+                owners[i] = owner
+            else
+                tname = cut_end_underscore(tables[i-1])
+                r = owners[i-1].reflections[tname.to_sym].options
+                owners[i] = r[:class_name].nil? ? eval(owners[i-1].to_s.gsub(/\w*$/, "")+tname.singularize.camelize) : eval("#{r[:class_name]}")
+            end
+        end
+        owners.reverse!
+        tables.reverse!
+        tables.each_index do |i|
+            if tables[i][-1, 1] == "_"
+                tables[i].reverse!.sub!("_", "").reverse!
+                @inner_joins << transfer_table_name(tables[i], owners[i])
+            end
+        end
+        # #process special id field in a belongs_to association
+        if field == "id"
+            if owners[0].reflections[tables[0].to_sym].macro.to_s == "belongs_to"
+                result = transfer_table_id(tables[0], owners[0])
+                @inner_joins.delete(tables[0]) if @inner_joins.include?(tables[0])
+                unless owners[1].nil?
+                    result = transfer_table_name(tables[1], owners[1]) + "." + result
+                end
+                tables.delete_at(0)
+                owners.delete_at(0)
+                return result if tables.empty?
+            end
+        end
     
-    #get include
-    if tables.length == 1 &&  tables[0] != @table_name
-      @new_include << tables[0].to_sym unless @new_include.include?(tables[0].to_sym)
-    else
-      tables_clone = tables[0..-1]
-      value = tables_clone.shift.to_sym
-      until tables_clone.empty?
-        hashes = {}
-        hashes[tables_clone.shift.to_sym] = value
-        value = hashes
-      end
-      @new_include << hashes unless hashes.nil? || @new_include.include?(hashes)
-    end
-    result ||= transfer_table_name(tables[0], owners[0]) + "." + field
+        # #get include
+        if tables.length == 1 &&  tables[0] != @table_name
+            @new_include << tables[0].to_sym unless @new_include.include?(tables[0].to_sym)
+        else
+            tables_clone = tables[0..-1]
+            value = tables_clone.shift.to_sym
+            until tables_clone.empty?
+                hashes = {}
+                hashes[tables_clone.shift.to_sym] = value
+                value = hashes
+            end
+            @new_include << hashes unless hashes.nil? || @new_include.include?(hashes)
+        end
+        result ||= transfer_table_name(tables[0], owners[0]) + "." + field
     
-  end
+    end
+
+    def raise_error(name, owner)
+        error_message = "Rquerypad error\n"
+        error_message << "owner.reflections:\n"
+        error_message << owner.reflections.inspect
+        error_message << '\n\nnot found by key:' << name.to_sym.to_s
+        raise error_message
+    end
   
-  def transfer_table_name(name, owner = @owner)
-    #p "=======================================", name,"=======================================", owner.inspect, "=======================================", owner.reflections.inspect, "=======================================" if  owner.reflections[name.to_sym].nil?
-    owner.reflections[name.to_sym].class_name.gsub(/([\w]+::)*/, "").pluralize.underscore
-  end
+    def transfer_table_name(name, owner = @owner)
+        raise_error(name, owner) if  owner.reflections[name.to_sym].nil?
+        owner.reflections[name.to_sym].class_name.gsub(/([\w]+::)*/, "").pluralize.underscore
+    end
   
-  def transfer_table_id(name, owner = @owner)
-    owner.reflections[name.to_sym].class_name.gsub(/([\w]+::)*/, "").underscore + "_id"
-  end
+    def transfer_table_id(name, owner = @owner)
+        raise_error(name, owner) if  owner.reflections[name.to_sym].nil?
+        owner.reflections[name.to_sym].class_name.gsub(/([\w]+::)*/, "").underscore + "_id"
+    end
   
-  def cut_end_underscore(str)
-    str = str.reverse.sub("_", "").reverse if str[-1, 1] == "_"
-    str
-  end
+    def cut_end_underscore(str)
+        str = str.reverse.sub("_", "").reverse if str[-1, 1] == "_"
+        str
+    end
   
-  def cut_end_underscore!(str)
-    str.reverse!.sub!("_", "").reverse! if str[-1, 1] == "_"
-  end
-end
+    def cut_end_underscore!(str)
+        str.reverse!.sub!("_", "").reverse! if str[-1, 1] == "_"
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rquerypad
 version: !ruby/object:Gem::Version 
-  version: 0.1.20
+  version: 0.1.21
 platform: ruby
 authors: 
 - Leon Li
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-09 00:00:00 +08:00
+date: 2009-04-15 00:00:00 +08:00
 default_executable: 
 dependencies: []