rquerypad 0.1.11

data/CHANGELOG

@@ -0,0 +1,48 @@
+Changes in version 0.1.11 (2008-04-29)
+-------------------------------------
+fix bugs about invalid cache for options
+Changes in version 0.1.10 (2008-03-26)
+-------------------------------------
+make alias_method name with 4rqp(for rquerypad) suffix to avoid confliction with the 3rd plugins
+
+Changes in version 0.1.9 (2008-03-26)
+-------------------------------------
+use deep copy to fix bug about options in cache is changed by later operation
+
+Changes in version 0.1.8 (2008-03-26)
+-------------------------------------
+use deep copy to fix bug about options in cache is changed by later operation
+
+Changes in version 0.1.7 (2008-03-26)
+-------------------------------------
+fix option value nil problem due to some 3rd plugins
+
+Changes in version 0.1.6 (2008-03-25)
+-------------------------------------
+fix bug about cache key not bind to class
+
+Changes in version 0.1.5 (2008-03-21)
+-------------------------------------
+fix bug when field is a id with single table which has belongs_to association, such as "parent.id"
+
+Changes in version 0.1.4 (2008-03-20)
+-------------------------------------
+support calculations call, such as count/avg...
+
+Changes in version 0.1.3 (2008-03-20)
+-------------------------------------
+fix about rails 1.2.6 support
+
+Changes in version 0.1.2 (2008-03-19)
+-------------------------------------
+fix inner join bug
+
+Changes in version 0.1.1 (2008-03-19)
+-------------------------------------
+put initialized code in rquerypad's init.rb, instead of project configuration
+support to rails 1.2.6
+
+
+Changes in version 0.1.0 (2008-03-18)
+-------------------------------------
+fix bug about table_name.field as parameter

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,66 @@
+Rquerypad, release 0.1.11 (Apr. 2008)
+=========
+Simplify query options with association automation and improve inner join for activerecord of rails
+
+Feature
+=======
+1. single name string decribe associations
+2. support to mix inner join and outer join with any order
+3. auto remove duplicated joins from other association in different depth
+4. support :conditions, :order, :group
+5. auto merge to original :include, :joins
+
+Install
+=======
+ruby script/plugin install http://rquerypad.rubyforge.org/svn/trunk/rquerypad
+or
+ruby script/plugin install http://rquerypad.googlecode.com/svn/trunk/rquerypad
+
+Example
+=======
+suppose the asscociations of User <-> Thread <-> Reply is 1:N:N
+
+@users = User.find(:all, :group => ["threads.created_at", "name"])
+generate:
+[:all, {:group=>"threads.created_at, users.name", :include=>[:threads]}]
+
+@users = User.find(:all, :conditions => ["threads_.replies.title = ?", "rquerypad"])
+generate:
+[:all, {:inner_joins=>["threads"], :conditions=>["replies.title = ?", "rquerypad"], :include=>[{:threads=>:replies}]}]
+#note: the :inner_joints is processed by rquerypad before sending sql to database
+
+@users = User.find(:all, :conditions => ["threads.replies.title = ? and threads.id = ?", "rquerypad", 1])
+generate:
+[:all, {:conditions=>["replies.title = ? and threads.id = ?", "rquerypad", 1], :include=>[{:threads=>:replies}]}]
+#note: single "threads" was removed from includes
+
+Setup
+=======
+#to set debug model, in rails initialized script
+$RQUERYPAD_DEBUG = true
+
+Test
+=======
+Note: current migrate script works only in rails 2.0
+
+1.Prepare
+
+the test depends on sqlite3 database, the following code should be add into your database.yml and place rquerypad.rb(copy from test.rb) in config/environment
+
+rquerypad:
+  adapter: sqlite3
+  database: vendor/plugins/rquerypad/test/db.rquerypad
+  timeout: 5000
+  
+2.database migrate
+
+execute the following script
+
+rake migrate
+
+3.start test
+
+execute the following script
+rake
+
+Copyright (c) 2008 Leon Li, released under the MIT license

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+PKG_NAME = "rquerypad"
+PKG_VERSION = "0.1.11"
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Za-z]*',
+  'lib/**/*',
+  'test/**/*',
+  'tasks/**/*',
+]
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Simplify query options with association automation and improve inner join for activerecord of rails"
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.rubyforge_project = 'rquerypad'
+  #s.executables = ['gem-sample']
+  #s.default_executable = 'gem-sample'
+  s.authors = ["Leon Li"]
+  s.email = "scorpio_leon@hotmail.com"
+  s.files = PKG_FILES
+  s.description = <<-EOF
+    Simplify query options with association automation and improve inner join for activerecord of rails
+  EOF
+end
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/lib/rquerypad.rb

@@ -0,0 +1,318 @@
+=begin Rquerypad
+author: Leon Li(scorpio_leon@hotmail.com)
+=end
+require 'md5'
+class Rquerypad
+  #todo scope support
+  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 %{
+        require "rquerypad"
+        
+        class << self
+          @@rquerypad_cache = {}
+          alias_method(:old_find_4rqp, :find) unless method_defined?(:old_find_4rqp)
+          alias_method(:old_cfswia_4rqp, :construct_finder_sql_with_included_associations) unless method_defined?(:old_cfswia_4rqp)
+          VALID_FIND_OPTIONS << :inner_joins
+          def find(*args)
+            options = #{if [].respond_to?(:extract_options!) then "args.extract_options!" else "extract_options_from_args!(args)" end}
+            if !options.empty? && (options.include?(:conditions) || options.include?(:group) || options.include?(:order))
+            #  if (!options.empty? && (!options[:conditions].nil? || !options[:group].nil? || !options[:order].nil?))
+	            #{"p 'original options:', options" if debug}
+	            cache_key = Rquerypad.options_key(options)
+              #p "cache_key: #\{cache_key\}"
+              #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)
+                rquerypad_cache[cache_key] = Marshal.dump(options)
+                #p "rquerypad_cache[cache_key]: #\{rquerypad_cache[cache_key]\}"
+              else
+                options = Marshal.load(rquerypad_cache[cache_key])
+	            end
+              #{"p 'new options:', options" if debug}
+            end
+            args += [options] unless options.empty?
+            old_find_4rqp *args 
+          end
+          def construct_finder_sql_with_included_associations(options, join_dependency)
+            sql = old_cfswia_4rqp(options, join_dependency)
+            #{"p('original sql', sql) unless options[:inner_joins].nil?" if debug}
+            sql = Rquerypad.process_inner_join(sql, options[:inner_joins]) unless options[:inner_joins].nil?
+            #{"p('new sql with inner join', sql) unless options[:inner_joins].nil?" if debug}
+            sql
+          end
+          def rquerypad_cache
+            @@rquerypad_cache
+          end
+        end
+      }
+      
+      ActiveRecord::Calculations.class_eval %{
+        require "rquerypad"
+        module ClassMethods
+          @@rquerypad_cache = {}
+          alias_method(:old_construct_calculation_sql_4rqp, :construct_calculation_sql) unless method_defined?(:old_construct_calculation_sql_4rqp)
+          CALCULATIONS_OPTIONS << :inner_joins
+          def construct_calculation_sql(operation, column_name, options)
+            if !options.empty? && (options.include?(:conditions) || options.include?(:group) || options.include?(:order))
+              #{"p 'original options:', options" if debug}
+              cache_key = Rquerypad.options_key(options)
+              if rquerypad_cache[cache_key].nil?
+                #{"p 'process for:', options" if debug}
+                Rquerypad.new(self).improve_options!(options)
+                rquerypad_cache[cache_key] = Marshal.load(Marshal.dump(options))
+              else
+                options = rquerypad_cache[cache_key]
+              end
+              #{"p 'new options:', options" if debug}
+            end
+            sql = old_construct_calculation_sql_4rqp(operation, column_name, options)
+            #{"p('original sql', sql) unless options[:inner_joins].nil?" if debug}
+            sql = Rquerypad.process_inner_join(sql, options[:inner_joins]) unless options[:inner_joins].nil?
+            #{"p('new sql with inner join', sql) unless options[:inner_joins].nil?" if debug}
+            sql
+          end
+          def rquerypad_cache
+            @@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]) 
+        end
+        def single_gt?(other)
+          return false if self == other
+          return !(single_lt?(other))
+        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
+    end
+    
+    def options_key(options)
+      key = options.to_a.to_s
+      key = MD5.hexdigest(key) if key.length > 100
+      key
+    end
+  end
+  def initialize(obj)
+    @owner = obj
+    @class_name = obj.to_s.scan(/(\w*::)*([^\(]*)/)[0][1]
+    @table_name = @class_name.pluralize.underscore
+    @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?
+      if key.to_s == "conditions"
+        option_hash[key] = improve_conditions(value)
+      elsif (key.to_s == "order" || key.to_s == "group" || key.to_s == "group_field")
+        option_hash[key] = improve_ordergroup(value).join(", ")
+      elsif (key.to_s == "include")
+        @old_include = value
+      end
+    end
+    return nil 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
+        end
+      end
+    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
+            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
+    end
+    @new_include = final_includes
+  end
+  
+  def improve_conditions(options)
+    if options.is_a?(Array)
+      str = options[0]
+      temp = str.scan(/'.*?'/)
+      #replace string in quote to avoid unecessary processing
+      str.gsub!(/'.*?'/, "'[??]'") unless temp.empty?
+      str.gsub!(/(([\w\(\)]+\.)+\w+)[ !><=]/) do |n|
+        #cut last char and abstract association for include
+        abstract_association(n[0..-2]) + n[-1, 1]
+      end
+      #add @table_name on single field
+      str.gsub!(/[\.]?\w+[\.]?/) {|x| x[-1, 1] == "." || ["and", "or", "is", "null", "not"].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
+      end
+      options[0] = str
+    end
+    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)
+    end
+    options
+  end
+  
+  def process_single!(key)
+    if key.include?(".")
+      if /^(.+)[ ]/ =~ key
+        key.sub!("#$1", abstract_association("#$1"))
+      else
+        key.sub!(/^.+$/, abstract_association(key))
+      end
+    else
+      key.sub!(/^.+$/, @tnwithdot + 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|
+      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) : Util::Common.str2class(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
+    
+  end
+  
+  def transfer_table_name(name, owner = @owner)
+    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 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

data/tasks/rquerypad_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rquerypad do
+#   # Task goes here
+# end

data/test/fixtures/replies.yml

@@ -0,0 +1,25 @@
+reply_one:
+  id: 1
+  title: "rquerypad"
+  thread_id: 1
+  user_id: 1
+  
+reply_two:
+  id: 2
+  title: "thank you"
+  thread_id: 2
+  user_id: 2
+  
+reply_three:
+  id: 3
+  title: "thank you-1"
+  thread_id: 2
+  parent_id: 2
+  user_id: 2
+
+reply_four:
+  id: 4
+  title: "thank you-2"
+  thread_id: 2
+  parent_id: 2
+  user_id: 2

data/test/fixtures/threads.yml

@@ -0,0 +1,17 @@
+thread_one:
+  id: 1
+  title: "welcome"
+  user_id: 1
+  created_at: "2008-03-16 00:00:00"
+  
+thread_two:
+  id: 2
+  title: "join us"
+  user_id: 2
+  created_at: "2008-03-17 00:00:00"
+  
+thread_three:
+  id: 3
+  title: "hello"
+  user_id: 2
+  created_at: "2008-03-16 20:00:00"

data/test/fixtures/users.yml

@@ -0,0 +1,7 @@
+user_one:
+  id: 1
+  name: leon
+  
+user_two:
+  id: 2
+  name: carrol

data/test/migrate/001_create_users.rb

@@ -0,0 +1,13 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string "name"
+      t.datetime  "created_at"
+      t.datetime  "updated_at"
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/test/migrate/002_create_threads.rb

@@ -0,0 +1,15 @@
+class CreateThreads < ActiveRecord::Migration
+  def self.up
+    create_table :threads do |t|
+      t.string  "title"
+      t.string  "content"
+      t.integer "user_id"
+      t.datetime  "created_at"
+      t.datetime  "updated_at"
+    end
+  end
+
+  def self.down
+    drop_table :threads
+  end
+end

data/test/migrate/003_create_replies.rb

@@ -0,0 +1,17 @@
+class CreateReplies < ActiveRecord::Migration
+  def self.up
+    create_table :replies do |t|
+      t.string  "title"
+      t.string  "content"
+      t.integer "user_id"
+      t.integer "thread_id"
+      t.integer "parent_id"
+      t.datetime  "created_at"
+      t.datetime  "updated_at"
+    end
+  end
+
+  def self.down
+    drop_table :replies
+  end
+end

data/test/model.rb

@@ -0,0 +1,17 @@
+module Model
+  class User < ActiveRecord::Base
+    has_many :threads
+    has_many :replies
+  end
+  class Thread < ActiveRecord::Base
+    has_many :replies
+    belongs_to :user
+  end
+  class Reply < ActiveRecord::Base
+    belongs_to :thread
+    has_many :replies
+    belongs_to :reply, :foreign_key => "parent_id"
+    belongs_to :user
+    acts_as_tree
+  end
+end

data/test/rquerypad_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+require 'rquerypad'
+require 'test/model'
+class RquerypadTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  include Model
+  def test_this_plugin
+    @fixture_path = 'vendor/plugins/rquerypad/test/fixtures'
+    
+    @users = User.find(:all, :group => ["threads.created_at", "name"])
+    assert_equal  @users.size, 2
+    
+    c = User.count(:conditions => ["threads_.replies.title = ?", "rquerypad"])
+    assert_equal  c, 1
+    
+    @users = User.find(:all, :conditions => ["threads.replies.title = ? and threads.id = ?", "rquerypad", 1])
+    assert_equal  @users.size, 1
+    
+    @replies = Reply.find(:all, :conditions => ["thread.id = ?", 2])
+    assert_equal  @replies.size, 3
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rquerypad'
+
+ENV["RAILS_ENV"] = "rquerypad"
+#require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require 'test_help'
+Test::Unit::TestCase.fixture_path = File.expand_path(File.dirname(__FILE__) + "/fixtures/")
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: rquerypad
+version: !ruby/object:Gem::Version 
+  version: 0.1.11
+platform: ruby
+authors: 
+- Leon Li
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-04 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: Simplify query options with association automation and improve inner join for activerecord of rails
+email: scorpio_leon@hotmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- lib
+- MIT-LICENSE
+- pkg
+- Rakefile
+- README
+- tasks
+- test
+- lib/rquerypad.rb
+- test/db.rquerypad
+- test/fixtures
+- test/fixtures/replies.yml
+- test/fixtures/threads.yml
+- test/fixtures/users.yml
+- test/migrate
+- test/migrate/001_create_users.rb
+- test/migrate/002_create_threads.rb
+- test/migrate/003_create_replies.rb
+- test/model.rb
+- test/rquerypad_test.rb
+- test/test_helper.rb
+- tasks/rquerypad_tasks.rake
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- none
+rubyforge_project: rquerypad
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Simplify query options with association automation and improve inner join for activerecord of rails
+test_files: []
+