ar-extensions 0.5.1

data/lib/ar-extensions/finders.rb

@@ -0,0 +1,76 @@
+module ActiveRecord::ConnectionAdapters::Quoting
+
+  alias :quote_orig :quote
+  def quote( value, column=nil ) # :nodoc:
+    if value.is_a?( Regexp )
+      "'#{value.inspect[1...-1]}'"
+    else
+      quote_orig( value, column )
+    end
+  end
+end
+
+
+class ActiveRecord::Base
+
+  class << self
+
+    private
+    
+    alias :sanitize_sql_orig :sanitize_sql
+    def sanitize_sql( arg ) # :nodoc:
+      return sanitize_sql_orig( arg ) if arg.nil?
+      if arg.respond_to?( :to_sql )
+        arg = sanitize_sql_by_way_of_duck_typing( arg ) #if arg.respond_to?( :to_sql )
+      elsif arg.is_a?( Hash )
+        arg = sanitize_sql_from_hash( arg ) #if arg.is_a?( Hash )
+      elsif arg.size == 2 and arg.first.is_a?( String ) and arg.last.is_a?( Hash )
+         arg = sanitize_sql_from_string_and_hash( arg ) # if arg.size == 2 and arg.first.is_a?( String ) and arg.last.is_a?( Hash )
+      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]+/        
+      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.each_pair do |key,val|
+        if val.respond_to?( :to_sql )  
+          conditions << sanitize_sql_by_way_of_duck_typing( val ) 
+          next
+        else
+          sql = nil
+          result = ActiveRecord::Extensions.process( key, val, self )
+          if result
+            conditions << result.sql if result.sql
+            values.push( result.value ) if result.value
+          else
+            conditions << "#{table_name}.#{connection.quote_column_name(key.to_s)} #{attribute_condition( val )} "
+            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,63 @@
+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]
+
+class ActiveRecord::ConnectionAdapters::MysqlAdapter # :nodoc:
+  include ActiveRecord::Extensions::FullTextSearching::FullTextSupport
+
+  def register_fulltext_extension( fulltext_key, options ) # :nodoc:
+    ActiveRecord::Extensions::FullTextSearching::MySQLFullTextExtension.register( fulltext_key, options )
+  end
+end

data/lib/ar-extensions/import.rb

@@ -0,0 +1,254 @@
+module ActiveRecord::Extensions::ConnectionAdapters ; end
+
+module ActiveRecord::Extensions::Import #:nodoc:
+  
+  module ImportSupport #:nodoc:
+    def supports_import? #:nodoc:
+      true
+    end
+  end
+  
+  module OnDuplicateKeyUpdateSupport #:nodoc:
+    def supports_on_duplicate_key_update? #:nodoc:
+      true
+    end
+  end
+  
+end
+
+class ActiveRecord::Base
+  class << self
+  
+    # Returns true if the current database connection adapter
+    # supports import functionality, otherwise returns false.
+    def supports_import?
+      connection.supports_import?
+    rescue NoMethodError
+      false
+    end
+    
+    # Returns true if the current database connection adapter
+    # supports on duplicate key update functionality, otherwise
+    # returns false.
+    def supports_on_duplicate_key_update?
+      connection.supports_on_duplicate_key_update?
+    rescue NoMethodError
+      false
+    end
+    
+    # Imports a collection of values to the database.  
+    #
+    # This is more efficient than using ActiveRecord::Base#create or
+    # ActiveRecord::Base#save multiple times. This method works well if
+    # you want to create more than one record at a time and do not care
+    # about having ActiveRecord objects returned for each record
+    # inserted. 
+    #
+    # This can be used with or without validations. It does not utilize
+    # the ActiveRecord::Callbacks during creation/modification while
+    # performing the import.
+    #
+    # == Usage
+    #  Model.import array_of_models
+    #  Model.import column_names, array_of_values
+    #  Model.import column_names, array_of_values, options
+    # 
+    # ==== Model.import array_of_models
+    # 
+    # With this form you can call _import_ passing in an array of model
+    # objects that you want updated.
+    #
+    # ==== Model.import column_names, array_of_values
+    #
+    # The first parameter +column_names+ is an array of symbols or
+    # strings which specify the columns that you want to update.
+    #
+    # The second parameter, +array_of_values+, is an array of
+    # arrays. Each subarray is a single set of values for a new
+    # record. The order of values in each subarray should match up to
+    # the order of the +column_names+.
+    #
+    # ==== Model.import column_names, array_of_values, options
+    #
+    # The first two parameters are the same as the above form. The third
+    # parameter, +options+, is a hash. This is optional. Please see
+    # below for what +options+ are available.
+    #
+    # == Options
+    # * +validate+ - true|false, tells import whether or not to use \
+    #    ActiveRecord validations. Validations are enforced by default.
+    # * +on_duplicate_key_update+ - an Array or Hash, tells import to \
+    #    use MySQL's ON DUPLICATE KEY UPDATE ability. See On Duplicate\
+    #    Key Update below.
+    #
+    # == Examples  
+    #  class BlogPost < ActiveRecord::Base ; end
+    #  
+    #  # Example using array of model objects
+    #  posts = [ BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT',
+    #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT2',
+    #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT3' ]
+    #  BlogPost.import posts
+    #
+    #  # Example using column_names and array_of_values
+    #  columns = [ :author_name, :title ]
+    #  values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
+    #  BlogPost.import columns, values 
+    #
+    #  # Example using column_names, array_of_value and options
+    #  columns = [ :author_name, :title ]
+    #  values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
+    #  BlogPost.import( columns, values, :validate => false  )
+    #
+    # == On Duplicate Key Update (MySQL only)
+    #
+    # The :on_duplicate_key_update option can be either an Array or a Hash. 
+    # 
+    # ==== Using an Array
+    #
+    # The :on_duplicate_key_update option can be an array of column
+    # names. The column names are the only fields that are updated if
+    # a duplicate record is found. Below is an example:
+    #
+    #   BlogPost.import columns, values, :on_duplicate_key_update=>[ :date_modified, :content, :author ]
+    #
+    # ====  Using A Hash
+    #
+    # The :on_duplicate_key_update option can be a hash of column name
+    # to model attribute name mappings. This gives you finer grained
+    # control over what fields are updated with what attributes on your
+    # model. Below is an example:
+    #   
+    #   BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :title => :title } 
+    #  
+    def import( *args )
+      options = { :validate=>true }
+      options.merge!( args.pop ) if args.last.is_a? Hash
+      
+      # assume array of model objects
+      if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
+        if args.length == 2
+          models = args.last
+          column_names = args.first
+        else
+          models = args.first
+          column_names = self.column_names.dup
+          column_names.delete( self.primary_key ) unless options[ :on_duplicate_key_update ]
+        end
+        
+        array_of_attributes = models.inject( [] ) do |arr,model|
+          attributes = []
+          column_names.each do |name| 
+            attributes << model.send( "#{name}_before_type_cast" ) 
+          end
+          arr << attributes
+        end
+        # supports 2-element array and array
+      elsif args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Array )
+        column_names, array_of_attributes = args
+      else
+        raise ArgumentError.new( "Invalid arguments!" )
+      end
+      
+      is_validating = options.delete( :validate )
+      
+      # dup the passed in array so we don't modify it unintentionally
+      array_of_attributes = array_of_attributes.dup
+      if is_validating
+        import_with_validations( column_names, array_of_attributes, options )
+      else
+        import_without_validations_or_callbacks( column_names, array_of_attributes, options )
+      end
+    end
+    
+    # TODO import_from_table needs to be implemented. 
+    def import_from_table( options ) # :nodoc:
+    end
+    
+    # Imports the passed in +column_names+ and +array_of_attributes+
+    # given the passed in +options+ Hash with validations. Returns an
+    # array of instances that failed validations. See
+    # ActiveRecord::Base.import for more information on
+    # +column_names+, +array_of_attributes+ and +options+.
+    def import_with_validations( column_names, array_of_attributes, options={} )
+      failed_instances = []
+      
+      # create instances for each of our column/value sets
+      arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )    
+      
+      # keep track of the instance and the position it is currently at. if this fails
+      # validation we'll use the index to remove it from the array_of_attributes
+      arr.each_with_index do |hsh,i| 
+        instance = new( hsh )
+        if not instance.valid?
+          array_of_attributes[ i ] = nil
+          failed_instances << instance
+        end    
+      end
+      array_of_attributes.compact!
+      
+      if not array_of_attributes.empty?
+        import_without_validations_or_callbacks( column_names, array_of_attributes, options )
+      end
+      failed_instances   
+    end
+    
+    # Imports the passed in +column_names+ and +array_of_attributes+
+    # given the passed in +options+ Hash. This will return the number
+    # of insert operations it took to create these records without
+    # validations or callbacks. See ActiveRecord::Base.import for more
+    # information on +column_names+, +array_of_attributes_ and
+    # +options+.
+    def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
+      escaped_column_names = quote_column_names( column_names )
+      columns = []
+      array_of_attributes.first.each_with_index { |arr,i| columns << columns_hash[ column_names[i] ] }
+      
+      if not supports_import?
+        columns_sql = "(" + escaped_column_names.join( ',' ) + ")"
+        insert_statements, values = [], []
+        array_of_attributes.each do |arr|
+          my_values = []
+          arr.each_with_index do |val,j|
+            my_values << connection.quote( val, columns[j] )
+          end
+          insert_statements << "INSERT INTO #{self.table_name} #{columns_sql} VALUES(" + my_values.join( ',' ) + ")"
+          connection.execute( insert_statements.last )
+        end
+        return
+      else
+        
+        # generate the sql
+        insert_sql = connection.multiple_value_sets_insert_sql( table_name, escaped_column_names, options )
+        values_sql = connection.values_sql_for_column_names_and_attributes( columns, array_of_attributes )
+        post_sql_statements = connection.post_sql_statements( table_name, options )
+        
+        # perform the inserts
+        number_of_inserts = connection.insert_many( 
+                                                   [ insert_sql, post_sql_statements ].flatten, 
+                                                   values_sql,
+                                                   "#{self.class.name} Create Many Without Validations Or Callbacks" )
+      end
+    end
+    
+    # Returns an array of quoted column names
+    def quote_column_names( names ) 
+      names.map{ |name| connection.quote_column_name( name ) }
+    end
+
+    
+    private
+    
+    # Returns an Array of Hashes for the passed in +column_names+ and +array_of_attributes+.
+    def validations_array_for_column_names_and_attributes( column_names, array_of_attributes ) # :nodoc:
+      arr = []
+      array_of_attributes.each do |attributes|
+        c = 0
+        hsh = attributes.inject( {} ){|hsh,attr| hsh[ column_names[c] ] = attr ; c+=1 ; hsh }
+        arr << hsh
+      end
+      arr
+    end
+    
+  end
+end