ghazel-ar-extensions 0.9.3

data/lib/ar-extensions/csv.rb

@@ -0,0 +1,309 @@
+begin 
+  require 'faster_csv'
+  require 'ar-extensions/csv'
+rescue LoadError => ex
+  STDERR.puts "FasterCSV is not installed. CSV functionality will not be included."
+  raise ex
+end
+
+
+# Adds CSV export options to ActiveRecord::Base models. 
+#
+# === Example 1, exporting all fields
+#  class Book < ActiveRecord::Base ; end
+#  
+#  book = Book.find( 1 )
+#  book.to_csv
+#
+# === Example 2, only exporting certain fields
+#  class Book < ActiveRecord::Base ; end
+#
+#  book = Book.find( 1 ) 
+#  book.to_csv( :only=>%W( title isbn )
+#
+# === Example 3, exporting a model including a belongs_to association
+#  class Book < ActiveRecord::Base 
+#    belongs_to :author
+#  end
+# 
+#  book = Book.find( 1 )
+#  book.to_csv( :include=>:author )
+#
+# This also works for a has_one relationship. The :include
+# option can also be an array of has_one/belongs_to 
+# associations. This by default includes all fields
+# on the belongs_to association.
+#
+# === Example 4, exporting a model including a has_many association
+#  class Book < ActiveRecord::Base 
+#    has_many :tags
+#  end
+# 
+#  book = Book.find( 1 )
+#  book.to_csv( :include=>:tags )
+#
+# This by default includes all fields on the has_many assocaition.
+# This can also be an array of multiple has_many relationships. The
+# array can be mixed with has_one/belongs_to associations array
+# as well. IE: :include=>[ :author, :sales ]
+#
+# === Example 5, nesting associations
+#  class Book < ActiveRecord::Base 
+#    belongs_to :author
+#    has_many :tags
+#  end
+#
+#  book = Book.find( 1 )
+#  book.to_csv( :includes=>{ 
+#                  :author => { :only=>%W( name ) },
+#                  :tags => { :only=>%W( tagname ) } )
+#
+# Each included association can receive an options Hash. This
+# allows you to nest the associations as deep as you want 
+# for your CSV export. 
+#
+# It is not recommended to nest multiple has_many associations, 
+# although nesting multiple has_one/belongs_to associations.
+#
+module ActiveRecord::Extensions::FindToCSV
+
+  def self.included(base)
+    if !base.respond_to?(:find_with_csv)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods        
+      end
+      class << base
+        alias_method_chain :find, :csv
+      end
+    end
+  end
+  
+  class FieldMap# :nodoc:
+    attr_reader :fields, :fields_to_headers
+ 
+    def initialize( fields, fields_to_headers ) # :nodoc:
+      @fields, @fields_to_headers = fields, fields_to_headers
+    end
+    
+    def headers # :nodoc:
+      @headers ||= fields.inject( [] ){ |arr,field| arr << fields_to_headers[ field ] }
+    end
+    
+  end
+
+  module ClassMethods # :nodoc:      
+    private
+
+    def to_csv_fields_for_nil # :nodoc:
+      self.columns.map{ |column| column.name }.sort
+    end                         
+
+    def to_csv_headers_for_included_associations( includes ) # :nodoc:
+      get_class = proc { |str| Object.const_get( self.reflections[ str.to_sym ].class_name ) }
+
+      case includes
+      when Symbol
+        [ get_class.call( includes ).to_csv_headers( :headers=>true, :naming=>":model[:header]" ) ]
+      when Array
+        includes.map do |association| 
+          clazz = get_class.call( association )
+          clazz.to_csv_headers( :headers=>true, :naming=>":model[:header]" )
+        end
+      when Hash
+        includes.sort_by{ |k| k.to_s }.inject( [] ) do |arr,(association,options)|
+          clazz = get_class.call( association )
+          if options[:headers].is_a?( Hash )
+            options.merge!( :naming=>":header" ) 
+          else
+            options.merge!( :naming=>":model[:header]" ) 
+          end
+          arr << clazz.to_csv_headers( options )
+        end
+      else
+        []
+      end
+    end
+    
+    public
+
+    def find_with_csv( *args ) # :nodoc:
+      results = find_without_csv( *args )
+      results.extend( ArrayInstanceMethods ) if results.is_a?( Array )
+      results
+    end
+
+    def to_csv_fields( options={} ) # :nodoc:
+      fields_to_headers, fields = {}, []
+      
+      headers = options[:headers]
+      case headers
+      when Array
+        fields = headers.map{ |e| e.to_s }
+      when Hash
+        headers = headers.inject( {} ){ |hsh,(k,v)| hsh[k.to_s] = v ; hsh }
+        fields = headers.keys.sort
+        fields.each { |field| fields_to_headers[field] = headers[field] }
+      else
+        fields = to_csv_fields_for_nil
+      end
+      
+      if options[:only]
+        specified_fields = options[:only].map{ |e| e.to_s }
+        fields.delete_if{ |field| not specified_fields.include?( field ) }
+      elsif options[:except]
+        excluded_fields = options[:except].map{ |e| e.to_s }
+        fields.delete_if{ |field| excluded_fields.include?( field ) }
+      end
+
+      fields.each{ |field| fields_to_headers[field] = field } if fields_to_headers.empty?
+
+      FieldMap.new( fields, fields_to_headers )
+    end
+    
+    # Returns an array of CSV headers passed in the array of +options+.
+    def to_csv_headers( options={} )
+      options = { :headers=>true, :naming=>":header" }.merge( options )
+      return nil if not options[:headers]
+
+      fieldmap = to_csv_fields( options )
+      headers = fieldmap.headers
+      headers.push( *to_csv_headers_for_included_associations( options[ :include ] ).flatten )
+      headers.map{ |header| options[:naming].gsub( /:header/, header ).gsub( /:model/, self.name.downcase ) }
+    end
+
+  end
+
+  
+  module InstanceMethods
+
+    private
+    
+    def add_to_csv_association_methods!(association_name)
+      association = self.send association_name
+      association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
+      association      
+    end
+    
+    def add_to_csv_association_data! data, to
+      if to.empty?
+        to.push( *data )
+      else
+        originals = to.dup
+        to.clear
+        data.each do |assoc_csv|
+          originals.each do |sibling|
+            to.push( sibling + assoc_csv )
+          end
+        end
+      end
+    end
+    
+    def to_csv_association_is_blank?(association)
+      association.nil? or (association.respond_to?( :empty? ) and association.empty?)      
+    end
+    
+    def to_csv_data_for_included_associations( includes ) # :nodoc:
+      get_class = proc { |str| Object.const_get( self.class.reflections[ str.to_sym ].class_name ) }
+
+      case includes
+      when Symbol
+        association = add_to_csv_association_methods! includes
+        if to_csv_association_is_blank?(association)
+          [ get_class.call( includes ).columns.map{ '' } ]
+        else
+          [ *association.to_csv_data ]
+        end
+      when Array
+        siblings = []
+        includes.each do |association_name|
+          association = add_to_csv_association_methods! association_name
+          if to_csv_association_is_blank?(association)
+            association_data = [ get_class.call( association_name ).columns.map{ '' }  ]
+          else
+            association_data = association.to_csv_data
+          end
+
+          add_to_csv_association_data! association_data, siblings
+        end
+        siblings
+      when Hash
+        sorted_includes = includes.sort_by{ |k| k.to_s }
+        siblings = []
+        sorted_includes.each do |(association_name,options)|
+          association = add_to_csv_association_methods! association_name
+          if to_csv_association_is_blank?(association)
+            association_data = [ get_class.call( association_name ).columns.map{ '' }  ]
+          else
+            association_data = association.to_csv_data( options )
+          end
+          add_to_csv_association_data! association_data, siblings
+        end
+        siblings
+      else
+        []
+      end
+    end
+    
+    public
+    
+    # Returns CSV data without any header rows for the passed in +options+.
+    def to_csv_data( options={} )
+      fields = self.class.to_csv_fields( options ).fields
+      data, model_data = [], fields.inject( [] ) { |arr,field| arr << attributes[field].to_s }
+      if options[:include]
+        to_csv_data_for_included_associations( options[:include ] ).map do |assoc_csv_data|
+          data << model_data + assoc_csv_data
+        end
+      else
+        data << model_data
+      end
+      data
+    end
+    
+    # Returns CSV data including header rows for the passed in +options+.
+    def to_csv( options={} )
+      FasterCSV.generate do |csv|
+        headers = self.class.to_csv_headers( options )
+        csv << headers if headers
+        to_csv_data( options ).each{ |data| csv << data }
+      end
+    end
+    
+  end
+
+  module ArrayInstanceMethods # :nodoc:
+    class NoRecordsError < StandardError ; end #:nodoc:
+
+    # Returns CSV headers for an array of ActiveRecord::Base
+    # model objects by calling to_csv_headers on the first
+    # element.
+    def to_csv_headers( options={} ) 
+      first.class.to_csv_headers( options )
+    end
+
+    # Returns CSV data without headers for an array of
+    # ActiveRecord::Base model objects by iterating over them and
+    # calling to_csv_data with the passed in +options+.
+    def to_csv_data( options={} )
+      inject( [] ) do |arr,model_instance|
+        arr.push( *model_instance.to_csv_data( options ) )
+      end
+    end
+
+    # Returns CSV data with headers for an array of ActiveRecord::Base
+    # model objects by iterating over them and calling to_csv with
+    # the passed in +options+.
+    def to_csv( options={} )
+      FasterCSV.generate do |csv|
+        headers = to_csv_headers( options )
+        csv << headers if headers
+        each do |model_instance| 
+          model_instance.to_csv_data( options ).each{ |data| csv << data }
+        end
+      end
+    end
+    
+  end
+
+end

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

@@ -0,0 +1,3 @@
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  include ActiveRecord::Extensions::Delete::DeleteSupport
+end

data/lib/ar-extensions/delete.rb

@@ -0,0 +1,143 @@
+module ActiveRecord::Extensions::Delete#:nodoc:
+  mattr_accessor :delete_batch_size
+  self.delete_batch_size = 15000
+
+  module DeleteSupport #:nodoc:
+    def supports_delete? #:nodoc:
+      true
+    end
+  end
+end
+
+class ActiveRecord::Base
+  supports_extension :delete
+  
+  class << self
+
+      # Delete all specified records with options
+      #
+      # == Parameters
+      # * +conditions+ - the conditions normally specified to +delete_all+
+      # * +options+ - hash map of additional parameters
+      #
+      # == Options
+      # * <tt>:limit</tt> - the maximum number of records to delete.
+      # * <tt>:batch</tt> - delete in batches specified to avoid database contention
+      # Multiple sql deletions are executed in order to avoid database contention
+      # This has no affect if used inside a transaction
+      #
+      # Delete up to 65 red tags
+      #  Tag.delete_all ['name like ?', '%red%'], :limit => 65
+      #
+      # Delete up to 65 red tags in batches of 20. This will execute up to
+      # 4 delete statements: 3 batches of 20 and the final batch of 5.
+      #  Tag.delete_all ['name like ?', '%red%'], :limit => 65, :batch => 20
+      def delete_all_with_extension(conditions = nil, options={})
+
+        #raise an error if delete is not supported and options are specified
+        supports_delete! if options.any?
+
+        #call the base method if no options specified
+        return delete_all_without_extension(conditions) unless options.any?
+
+        #batch delete
+        return delete_all_batch(conditions, options[:batch], options[:limit]) if options[:batch]
+
+        #regular delete with limit
+        connection.delete(delete_all_extension_sql(conditions, options), "#{name} Delete All")
+      end
+
+      alias_method_chain :delete_all, :extension
+
+
+      # Utility function to delete all but one of the duplicate records
+      # matching the fields specified. This method will make the records
+      # unique for the specified fields.
+      #
+      # == Options
+      # * <tt>:fields</tt> - the fields to match on
+      # * <tt>:conditions</tt> - additional conditions
+      # * <tt>:winner_clause</tt> - the part of the query specifying what wins. Default winner is that with the greatest id.
+      # * <tt>:query_field</tt> -> the field to use to determine the winner. Defaults to primary_key (id). The tables are aliased
+      #  to c1 and c2 respectively
+      # == Examples
+      # Make all the phone numbers of contacts unique by deleting the duplicates with the highest ids
+      #   Contacts.delete_duplicates(:fields=>['phone_number_id'])
+      #
+      # Delete all tags that are the same preserving the ones with the highest id
+      #   Tag.delete_duplicates :fields => [:name], :winner_clause => "c1.id < c2.id"
+      #
+      # Remove duplicate invitations (those that from the same person and to the same recipient)
+      # preseving the first ones inserted
+      #  Invitation.delete_duplicates :fields=>[:event_id, :from_id, :recipient_id]
+      def delete_duplicates(options={})
+        supports_delete!
+
+        options[:query_field]||= primary_key
+
+        query = "DELETE FROM"
+        query << " c1 USING #{quoted_table_name} c1, #{quoted_table_name} c2"
+        query << " WHERE ("
+        query << options[:fields].collect{|field| "c1.#{field} = c2.#{field}" }.join(" and ")
+        query << " and (#{sanitize_sql(options[:conditions])})" unless options[:conditions].blank?
+        query << " and "
+        query << (options[:winner_clause]||"c1.#{options[:query_field]} > c2.#{options[:query_field]}")
+        query << ")"
+
+        self.connection.execute(self.send(:sanitize_sql, query))
+      end
+
+      protected
+
+
+      # Delete all records specified in batches
+      #
+      # == Parameters
+      # * +conditions+ - the conditions normally specified to +delete_all+
+      # * +batch+ - the size of the batches to delete. defaults to 15000
+      # * +limit+ - the maximum number of records to delete
+      #
+      def delete_all_batch(conditions=nil, batch=nil, limit=nil)#:nodoc:
+
+        #update the batch size if batch is nil or true or 0
+        if batch.nil? || !batch.is_a?(Fixnum) || batch.to_i == 0
+          batch = ActiveRecord::Extensions::Delete.delete_batch_size
+        end
+
+
+        sql = delete_all_extension_sql(conditions, :limit => batch)
+        page_num = total = 0
+
+        loop {
+          page_num += 1
+
+          #if this is the last batch query and limit is set
+          #only delete the remainer
+          if limit && (total + batch > limit)
+             sql = delete_all_extension_sql(conditions, :limit => (limit - total))
+          end
+
+          count = connection.delete(sql, "#{name} Delete All Batch #{page_num}")
+          total += count
+
+          # Return if
+          #  * last query did not return the batch size (meaning nothing left to delete)
+          #  * we have reached our limit
+           if (count < batch) || (limit && (total >= limit))
+             return total
+           end
+        }
+      end
+
+      #generate the delete SQL with limit
+      def delete_all_extension_sql(conditions, options={})#:nodoc:
+        sql = "DELETE FROM #{quoted_table_name} "
+        add_conditions!(sql, conditions, scope(:find))
+        connection.add_limit_offset!(sql, options)
+        sql
+      end
+
+  end
+
+end
+