wunderbread-ar-extensions 0.8.3

data/lib/ar-extensions/finder_options.rb

@@ -0,0 +1,208 @@
+# ActiveRecord::Extensions::FinderOptions provides additional functionality to the ActiveRecord
+# ORM library created by DHH for Rails.
+#
+# == Using finder_sql_to_string
+# Expose the finder sql to a string. The options are identical to those accepted by <tt>find(:all, options)</tt>
+# the find method takes.
+# === Example:
+#   sql = Contact.finder_sql_to_string(:include => :primary_email_address)
+#   Contact.find_by_sql(sql + 'USE_INDEX(blah)')
+#
+# == Enhanced Finder Options
+# Add index hints, keywords, and pre and post SQL to the query without writing direct SQL
+# === Parameter options:
+# * <tt>:pre_sql</tt> appends SQL after the SELECT and before the selected columns
+#
+#  sql = Contact.find :first, :pre_sql => "HIGH_PRIORITY", :select => 'contacts.name', :conditions => 'id = 5'
+#  SQL> SELECT HIGH_PRIORITY contacts.name FROM `contacts` WHERE id = 5
+#
+# * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+#  Contact.find :first, :post_sql => 'FOR UPDATE', :select => 'contacts.name', :conditions => 'id = 5'
+#  SQL> SELECT contacts.name FROM `contacts` where id == 5 FOR UPDATE
+#
+#  Book.find :all, :post_sql => 'USE_INDEX(blah)'
+#  SQL> SELECT books.* FROM `books` USE_INDEX(blah)
+#
+# * <tt>:override_select</tt> is used to override the <tt>SELECT</tt> clause of eager loaded associations
+# The <tt>:select</tt> option is ignored by the vanilla ActiveRecord when using eager loading with associations (when <tt>:include</tt> is used)
+# (refer to http://dev.rubyonrails.org/ticket/5371)
+# The <tt>:override_select</tt> options allows us to directly specify a <tt>SELECT</tt> clause without affecting the operations of legacy code  (ignore <tt>:select</tt>)
+# of the current code. Several plugins are available that enable select with eager loading
+# Several plugins exist to force <tt>:select</tt> to work with eager loading.
+#
+# <tt>script/plugin install http://arperftoolkit.rubyforge.org/svn/trunk/eload_select/ </tt>
+#
+# * <tt>:having</tt> only works when <tt>:group</tt> option is specified
+#  Book.find(:all, :select => 'count(*) as count_all, topic_id', :group => :topic_id, :having => 'count(*) > 1')
+#  SQL>SELECT count(*) as count_all, topic_id FROM `books`  GROUP BY topic_id HAVING count(*) > 1
+#
+# == Developers
+# * Blythe Dunham http://blythedunham.com
+#
+# == Homepage
+# * Project Site: http://www.continuousthinking.com/tags/arext
+# * Rubyforge Project: http://rubyforge.org/projects/arext
+# * Anonymous SVN: svn checkout svn://rubyforge.org/var/svn/arext
+#
+require 'active_record/version'
+module ActiveRecord::Extensions::FinderOptions
+  def self.included(base)
+
+    #alias and include only if not yet defined
+    unless base.respond_to?(:construct_finder_sql_ext)
+      base.extend ClassMethods
+      base.extend ActiveRecord::Extensions::SqlGeneration
+      base.class_eval do
+        class << self
+          VALID_FIND_OPTIONS.concat([:pre_sql, :post_sql, :keywords, :ignore, :rollup, :override_select, :having, :index_hint])
+          alias_method              :construct_finder_sql, :construct_finder_sql_ext
+          alias_method_chain        :construct_finder_sql_with_included_associations, :ext
+        end
+      end
+   end
+  end
+
+  module ClassMethods
+    # Return a string containing the SQL used with the find(:all)
+    # The options are the same as those with find(:all)
+    #
+    # Additional parameter of
+    # <tt>:force_eager_load</tt> forces eager loading even if the
+    #  column is not referenced.
+    #
+    #   sql = Contact.finder_sql_to_string(:include => :primary_email_address)
+    #   Contact.find_by_sql(sql + 'USE_INDEX(blah)')
+    def finder_sql_to_string(options)
+      
+      select_sql = self.send(
+        (use_eager_loading_sql?(options) ? :finder_sql_with_included_associations : :construct_finder_sql),
+        options.reject{|k,v| k == :force_eager_load}).strip
+
+    end
+
+    protected
+
+    # use eager loading sql (join associations) if inclu
+    def use_eager_loading_sql?(options)# :nodoc:
+      include_associations = merge_includes(scope(:find, :include), options[:include])
+      return ((include_associations.any?) &&
+              (options[:force_eager_load].is_a?(TrueClass) ||
+               references_eager_loaded_tables?(options)))
+
+    end
+
+    # construct_finder_sql is called when not using eager loading (:include option is NOT specified)
+    def construct_finder_sql_ext(options) # :nodoc:
+
+      #add piggy back option if plugin is installed
+      add_piggy_back!(options) if self.respond_to? :add_piggy_back!
+
+      scope = scope(:find)
+      sql = pre_sql_statements(options)
+      sql  << "#{options[:select] || options[:override_select] || (scope && scope[:select]) || default_select(options[:joins] || (scope && scope[:joins]))} "
+      sql << "FROM #{options[:from]  || (scope && scope[:from]) || quoted_table_name} "
+      sql << "#{options[:index_hint]} " if options[:index_hint]
+
+      add_joins!(sql, options[:joins], scope)
+      add_conditions!(sql, options[:conditions], scope)
+      add_group_with_having!(sql, options[:group], options[:having], scope)
+      
+      add_order!(sql, options[:order], scope)
+      add_limit!(sql, options, scope)
+      add_lock!(sql, options, scope)
+
+      sql << post_sql_statements(options)
+      sql
+
+    end
+
+    #override the constructor for use with associations (:include option)
+    #directly use eager select if that plugin is loaded instead of this one
+    def construct_finder_sql_with_included_associations_with_ext(options, join_dependency)#:nodoc
+      if respond_to?(:construct_finder_sql_with_included_associations_with_eager_select)
+        return construct_finder_sql_with_included_associations_with_eager_select(options, join_dependency)
+      else
+        scope = scope(:find)
+        sql = pre_sql_statements(options)
+        sql << "#{options[:override_select]||column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} "
+        sql << "#{options[:index_hint]} " if options[:index_hint]
+        sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+
+
+        add_joins!(sql, options[:joins], scope)
+        add_conditions!(sql, options[:conditions], scope)
+
+
+        add_limited_ids_condition!(sql, options_with_group(options), join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
+
+        add_group_with_having!(sql, options[:group], options[:having], scope)
+        add_order!(sql, options[:order], scope)
+        add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
+        add_lock!(sql, options, scope)
+
+        sql << post_sql_statements(options)
+
+        return sanitize_sql(sql)
+      end
+    end
+
+    #generate the finder sql for use with associations (:include => :something)
+    def finder_sql_with_included_associations(options = {})#:nodoc
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
+      sql = construct_finder_sql_with_included_associations_with_ext(options, join_dependency)
+    end
+    
+
+    # Before Version 2.3.0 there was no :having option
+    # Add this option to previous versions by overriding add_group!
+    # to accept a hash with keys :group and :having instead of just group
+    # this avoids having to completely rewrite dependent functions like
+    # construct_finder_sql_for_association_limiting
+
+    if ActiveRecord::VERSION::STRING < '2.3.1'
+      #add_group! in version 2.3 adds having already
+      #copy that implementation
+
+      def add_group_with_having!(sql, group, having, scope =:auto)
+        if group
+          sql << " GROUP BY #{group}"
+          sql << " HAVING #{sanitize_sql(having)}" if having
+        else
+          scope = scope(:find) if :auto == scope
+          if scope && (scoped_group = scope[:group])
+            sql << " GROUP BY #{scoped_group}"
+            sql << " HAVING #{sanitize_sql(scope[:having])}" if scope[:having]
+          end
+        end
+      end
+
+      def add_group!(sql, group_options, scope = :auto)#:nodoc:
+        group, having = if group_options.is_a?(Hash) && group_options.has_key?(:group)
+          [group_options[:group] , group_options[:having]]
+        else
+          [group_options, nil]
+        end
+        add_group_with_having!(sql, group, having, scope)
+      end
+
+      def options_with_group(options)#:nodoc:
+        if options[:group]
+          options.merge(:group => {:group => options[:group], :having => options[:having]})
+        else
+          options
+        end
+      end
+
+    #for Version 2.3 and greater, define options_with_group to pass itself
+    else
+      def options_with_group(options)#:nodoc:
+        options
+      end
+      
+      def add_group_with_having!(sql, group, having, scope =:auto)#:nodoc:
+        add_group!(sql, group, having, scope)
+      end
+    end
+
+  end
+end

data/lib/ar-extensions/finder_options/mysql.rb

@@ -0,0 +1,6 @@
+# Although the finder options actually override ActiveRecord::Base functionality instead of
+# connector functionality, the methods are included here to keep the syntax of 0.8.0 intact
+#
+# To include finder options, use:
+# require 'ar-extensions/finder_options/mysql.rb'
+ActiveRecord::Base.send :include, ActiveRecord::Extensions::FinderOptions

data/lib/ar-extensions/finders.rb

@@ -0,0 +1,95 @@
+require 'active_record/version'
+
+module ActiveRecord::ConnectionAdapters::Quoting
+
+  alias :quote_before_arext :quote
+  def quote( value, column=nil ) # :nodoc:
+    if value.is_a?( Regexp )
+      "'#{value.inspect[1...-1]}'"
+    else
+      quote_before_arext( value, column )
+    end
+  end
+end
+
+class ActiveRecord::Base
+
+  class << self
+
+    private
+    
+    alias :sanitize_sql_orig :sanitize_sql
+    def sanitize_sql( arg ) # :nodoc:
+      return if arg.blank? # don't process arguments like [], {}, "" or nil
+      if arg.respond_to?( :to_sql )
+        arg = sanitize_sql_by_way_of_duck_typing( arg )
+      elsif arg.is_a?( Hash )
+        arg = sanitize_sql_from_hash( arg ) 
+      elsif arg.is_a?( Array ) and arg.size == 2 and arg.first.is_a?( String ) and arg.last.is_a?( Hash )
+        arg = sanitize_sql_from_string_and_hash( arg ) 
+      end
+      sanitize_sql_orig( arg )
+    end
+    
+    def sanitize_sql_by_way_of_duck_typing( arg ) #: nodoc:
+      arg.to_sql( caller )
+    end
+
+    def sanitize_sql_from_string_and_hash( arr ) # :nodoc:
+      return arr if arr.first =~ /\:[\w]+/
+      return arr if arr.last.empty? # skip empty hash conditions, ie: :conditions => ["", {}]
+      arr2 = sanitize_sql_from_hash( arr.last )
+      if arr2.empty?
+        conditions = arr.first
+      else
+        conditions = [  arr.first <<  " AND (#{arr2.first})" ]
+        conditions.push( *arr2[1..-1] )
+      end
+      conditions
+    end
+    
+    def sanitize_sql_from_hash( hsh ) #:nodoc:
+      conditions, values = [], []
+      hsh = expand_hash_conditions_for_aggregates(hsh) # introduced in Rails 2.0.2
+
+      hsh.each_pair do |key,val|
+        if val.respond_to?( :to_sql )  
+          conditions << sanitize_sql_by_way_of_duck_typing( val ) 
+          next
+        elsif val.is_a?(Hash) # don't mess with ActiveRecord hash nested hash functionality
+          conditions << sanitize_sql_hash_for_conditions(key => val)
+        else
+          sql = nil
+          result = ActiveRecord::Extensions.process( key, val, self )
+          if result
+            conditions << result.sql
+            values.push( result.value ) unless result.value.nil?
+          else
+            # Extract table name from qualified attribute names.
+            attr = key.to_s
+            if attr.include?('.')
+              table_name, attr = attr.split('.', 2)
+              table_name = connection.quote_table_name(table_name)
+            else
+              table_name = quoted_table_name
+            end
+            # ActiveRecord in 2.3.1 changed the method signature for
+            # the method attribute_condition
+            if ActiveRecord::VERSION::STRING < '2.3.1'
+              conditions << "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition( val )} "
+            else  
+              conditions << attribute_condition("#{table_name}.#{connection.quote_column_name(attr)}", val)
+            end            
+            values << val
+          end
+        end
+      end
+        
+      conditions = conditions.join( ' AND ' )
+      return [] if conditions.size == 1 and conditions.first.empty?
+      [ conditions, *values ]
+    end
+       
+  end
+  
+end

data/lib/ar-extensions/foreign_keys.rb

@@ -0,0 +1,70 @@
+# Enables support for enabling and disabling foreign keys
+# for the underlyig database connection for ActiveRecord.
+#
+# This can be used with or without block form. This also
+# uses the connection attached to the model.
+#
+# ==== Example 1, without block form
+#   Project.foreign_keys.disable
+#   Project.foreign_keys.enable  
+#  
+# If you use this form you have to manually re-enable the foreign
+# keys.
+#
+# ==== Example 2, with block form
+#   Project.foreign_keys.disable do 
+#     # ...
+#   end
+#
+#  Project.foreign_keys.enable do
+#    # ...
+#  end
+#
+# If you use the block form the foreign keys are automatically
+# enabled or disabled when the block exits. This currently
+# does not restore the state of foreign keys to the state before
+# the block was entered. 
+#
+# Note: If you use the disable block foreign keys
+# will be enabled after the block exits. If you use the enable block foreign keys
+# will be disabled after the block exits.
+#
+# TODO: check the external state and restore that state when using block form.
+module ActiveRecord::Extensions::ForeignKeys
+
+  class ForeignKeyController # :nodoc:
+    attr_reader :clazz
+
+    def initialize( clazz )
+      @clazz = clazz
+    end
+
+    def disable # :nodoc:
+      if block_given?
+        disable
+        yield
+        enable
+      else
+        clazz.connection.execute "set foreign_key_checks = 0"
+      end
+    end
+    
+    def enable #:nodoc:
+      if block_given?
+        enable
+        yield
+        disable
+      else
+        clazz.connection.execute "set foreign_key_checks = 1"
+      end
+    end
+   
+  end #end ForeignKeyController
+  
+  def foreign_keys # :nodoc:
+    ForeignKeyController.new( self )
+  end
+
+end
+
+ActiveRecord::Base.extend( ActiveRecord::Extensions::ForeignKeys )

data/lib/ar-extensions/fulltext.rb

@@ -0,0 +1,62 @@
+require 'forwardable' 
+
+# FullTextSearching provides fulltext searching capabilities
+# if the underlying database adapter supports it. Currently
+# only MySQL is supported.
+module ActiveRecord::Extensions::FullTextSearching 
+
+  module FullTextSupport # :nodoc:
+    def supports_full_text_searching? #:nodoc:
+      true
+    end
+  end
+  
+end
+
+class ActiveRecord::Base
+  class FullTextSearchingNotSupported < StandardError ; end
+
+  class << self
+
+    # Adds fulltext searching capabilities to the current model
+    # for the given fulltext key and option hash.
+    #
+    # == Parameters
+    # * +fulltext_key+ - the key/attribute to be used to as the fulltext index 
+    # * +options+ - the options hash.
+    #
+    # ==== Options
+    # * +fields+ - an array of field names to be used in the fulltext search
+    #
+    # == Example
+    #
+    #  class Book < ActiveRecord::Base
+    #    fulltext :title, :fields=>%W( title publisher author_name )    
+    #  end
+    #  
+    #  # To use the fulltext index
+    #  Book.find :all, :conditions=>{ :match_title => 'Zach' }
+    #
+    def fulltext( fulltext_key, options )
+      connection.register_fulltext_extension( fulltext_key, options )
+    rescue NoMethodError
+      logger.warn "FullTextSearching is not supported for adapter!"
+      raise FullTextSearchingNotSupported.new
+    end
+
+    # Returns true if the current connection adapter supports full
+    # text searching, otherwise returns false.
+    def supports_full_text_searching?
+      connection.supports_full_text_searching?
+    rescue NoMethodError
+      false
+    end
+  end
+
+end
+
+
+
+
+
+

data/lib/ar-extensions/fulltext/mysql.rb

@@ -0,0 +1,44 @@
+# This adds FullText searching functionality for the MySQLAdapter.
+class ActiveRecord::Extensions::FullTextSearching::MySQLFullTextExtension
+  extend Forwardable
+  
+  class << self
+    extend Forwardable
+    
+    def register( fulltext_key, options ) # :nodoc:
+      @fulltext_registry ||= ActiveRecord::Extensions::Registry.new
+      @fulltext_registry.register( fulltext_key, options )
+    end
+    
+    def registry # :nodoc:
+      @fulltext_registry
+    end
+    
+    def_delegator :@fulltext_registry, :registers?, :registers?
+  end
+  
+  RGX = /^match_(.+)/
+  
+  def process( key, val, caller ) # :nodoc:
+    match_data = key.to_s.match( RGX )
+    return nil unless match_data
+    fulltext_identifier = match_data.captures[0].to_sym
+    if self.class.registers?( fulltext_identifier )
+      fields = self.class.registry.options( fulltext_identifier )[:fields]
+      str = "MATCH ( #{fields.join( ',' )} ) AGAINST (#{caller.connection.quote(val)})"
+      return ActiveRecord::Extensions::Result.new( str, nil )
+    end
+    nil
+  end
+  
+  def_delegator 'ActiveRecord::Extensions::FullTextSupport::MySQLFullTextExtension', :register    
+end
+ActiveRecord::Extensions.register ActiveRecord::Extensions::FullTextSearching::MySQLFullTextExtension.new, :adapters=>[:mysql]
+
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  include ActiveRecord::Extensions::FullTextSearching::FullTextSupport
+
+  def register_fulltext_extension( fulltext_key, options ) # :nodoc:
+    ActiveRecord::Extensions::FullTextSearching::MySQLFullTextExtension.register( fulltext_key, options )
+  end
+end