ar-extensions 0.5.1

data/db/migrate/generic_schema.rb

@@ -0,0 +1,59 @@
+ActiveRecord::Schema.define do
+
+  create_table :schema_info, :force=>true do |t|
+    t.column :version, :integer, :unique=>true
+  end
+  SchemaInfo.create :version=>SchemaInfo::VERSION
+
+  create_table :topics, :force=>true do |t|
+    t.column :title, :string, :null=>false
+    t.column :author_name, :string
+    t.column :author_email_address, :string
+    t.column :written_on, :datetime
+    t.column :bonus_time, :time
+    t.column :last_read, :datetime
+    t.column :content, :text
+    t.column :approved, :boolean, :default=>'1'
+    t.column :replies_count, :integer
+    t.column :parent_id, :integer
+    t.column :type, :string
+  end
+
+  create_table :projects, :force=>true do |t|
+    t.column :name, :string
+    t.column :type, :string    
+  end
+  
+  create_table :developers, :force=>true do |t|
+    t.column :name, :string
+    t.column :salary, :integer, :default=>'70000'
+    t.column :created_at, :datetime
+    t.column :team_id, :integer
+    t.column :updated_at, :datetime
+  end
+
+  create_table :addresses, :force=>true do |t|
+    t.column :address, :string
+    t.column :city, :string
+    t.column :state, :string
+    t.column :zip, :string
+    t.column :developer_id, :integer
+  end
+
+  create_table :teams, :force=>true do |t|
+    t.column :name, :string
+  end
+  
+  create_table :books, :force=>true do |t|
+    t.column :title, :string, :null=>false
+    t.column :publisher, :string, :null=>false
+    t.column :author_name, :string, :null=>false
+    t.column :created_at, :time
+  end  
+
+  create_table :languages, :force=>true do |t|
+    t.column :name, :string
+    t.column :developer_id, :integer
+  end
+
+end

data/db/migrate/mysql_schema.rb

@@ -0,0 +1,26 @@
+ActiveRecord::Schema.define do
+ 
+  create_table :test_myisam, :options=>'ENGINE=MyISAM', :force=>true do |t|
+    t.column :my_name, :string, :null=>false
+    t.column :description, :string
+  end
+  
+  create_table :test_innodb, :options=>'ENGINE=InnoDb', :force=>true do |t|
+    t.column :my_name, :string, :null=>false
+    t.column :description, :string
+  end
+
+  create_table :test_memory, :options=>'ENGINE=Memory', :force=>true do |t|
+    t.column :my_name, :string, :null=>false
+    t.column :description, :string
+  end
+  
+  create_table :books, :options=>'ENGINE=MyISAM', :force=>true do |t|
+    t.column :title, :string, :null=>false
+    t.column :publisher, :string, :null=>false
+    t.column :author_name, :string, :null=>false
+    t.column :created_at, :datetime
+  end
+  execute "ALTER TABLE books ADD FULLTEXT( `title`, `publisher`, `author_name` )"
+
+end

data/db/migrate/version.rb

@@ -0,0 +1,4 @@
+class SchemaInfo < ActiveRecord::Base
+  set_table_name 'schema_info'
+  VERSION = 5
+end

data/init.rb

@@ -0,0 +1,32 @@
+require 'ostruct'
+begin ; require 'active_record' ; rescue LoadError; require 'rubygems'; require 'active_record'; end
+
+dir = File.dirname( __FILE__ )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'version' ) )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'extensions' ) )
+
+begin 
+  require 'faster_csv' 
+  require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'csv' ) )
+rescue LoadError
+  STDERR.puts "FasterCSV is not installed. CSV functionality will not be included."
+end
+
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'foreign_keys' ) )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'fulltext' ) )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'fulltext', 'mysql' ) )
+
+db_adapters_path = File.expand_path( File.join(  dir, 'lib/ar-extensions', 'adapters' ) )
+
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'import' ) )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'import', 'mysql' ) )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'import', 'postgresql' ) )
+
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'finders' ) )
+
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'temporary_table' ) )
+require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'temporary_table', 'mysql' ) )
+
+require File.expand_path( File.join(  db_adapters_path, 'abstract_adapter' ) )
+require File.expand_path( File.join(  db_adapters_path,'mysql_adapter' ) )
+

data/lib/ar-extensions.rb

@@ -0,0 +1,4 @@
+begin ; require 'rubygems' rescue LoadError; end
+require 'active_record' # ActiveRecord loads the Benchmark library automatically
+
+require File.expand_path(File.join( File.dirname( __FILE__ ), '..', 'init.rb' ))

data/lib/ar-extensions/adapters/abstract_adapter.rb

@@ -0,0 +1,83 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter # :nodoc:
+      NO_MAX_PACKET = 0
+    
+      # +sql+ can be a single string or an array. If it is an array all 
+      # elements that are in position >= 1 will be appended to the final SQL.
+      def insert_many( sql, values, *args ) # :nodoc:
+        # the number of inserts default
+        number_of_inserts = 0
+        
+        base_sql,post_sql = if sql.is_a?( String )
+          [ sql, '' ]
+        elsif sql.is_a?( Array )
+          [ sql.shift, sql.join( ' ' ) ]
+        end
+        
+        sql_size = base_sql.size + post_sql.size 
+
+        # the number of bytes the requested insert statement values will take up
+        values_in_bytes = self.class.sum_sizes( *values )
+        
+        # the number of bytes (commas) it will take to comma separate our values
+        comma_separated_bytes = values.size-1
+        
+        # the total number of bytes required if this statement is one statement
+        total_bytes = sql_size + values_in_bytes + comma_separated_bytes
+        
+        max = max_allowed_packet
+        
+        # if we can insert it all as one statement
+        if NO_MAX_PACKET == max or total_bytes < max
+          number_of_inserts += 1
+          sql2insert = base_sql + values.join( ',' ) + post_sql
+          insert( sql2insert, *args )
+        else
+          value_sets = self.class.get_insert_value_sets( values, sql_size, max )
+          value_sets.each do |values|
+            number_of_inserts += 1
+            sql2insert = base_sql + values.join( ',' ) + post_sql
+            insert( sql2insert, *args )
+          end
+        end        
+        
+        number_of_inserts
+      end
+
+      # Returns the sum of the sizes of the passed in objects. This should
+      # probably be moved outside this class, but to where?
+      def self.sum_sizes( *objects ) # :nodoc:
+        objects.inject( 0 ){|sum,o| sum += o.size }
+      end
+            
+      # Returns the maximum number of bytes that the server will allow
+      # in a single packet
+      def max_allowed_packet
+        NO_MAX_PACKET
+      end
+      
+      def self.get_insert_value_sets( values, sql_size, max_bytes ) # :nodoc:
+        value_sets = []          
+        arr, current_arr_values_size, current_size = [], 0, 0
+        values.each_with_index do |val,i|
+          comma_bytes = arr.size
+          sql_size_thus_far = sql_size + current_size + val.size + comma_bytes
+          if NO_MAX_PACKET == max_bytes or sql_size_thus_far <= max_bytes
+            current_size += val.size            
+            arr << val
+          else
+            value_sets << arr
+            arr = [ val ]
+            current_size = val.size
+          end
+          
+          # if we're on the last iteration push whatever we have in arr to value_sets
+          value_sets << arr if i == (values.size-1)
+        end
+        [ *value_sets ]
+      end     
+    
+    end
+  end
+end

data/lib/ar-extensions/adapters/mysql_adapter.rb

@@ -0,0 +1,14 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class MysqlAdapter # :nodoc:
+           
+      # Returns the maximum number of bytes that the server will allow
+      # in a single packet
+      def max_allowed_packet # :nodoc:
+        result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+        result.fetch_row[1].to_i
+      end
+    
+    end #end MysqlAdapter
+  end #end ConnectionAdapters
+end #end ActiveRecord

data/lib/ar-extensions/adapters/postgresql.rb

@@ -0,0 +1,7 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class PostgreSQLAdapter # :nodoc:
+    
+    end
+  end
+end

data/lib/ar-extensions/csv.rb

@@ -0,0 +1,302 @@
+
+require 'faster_csv'
+require 'ostruct'
+
+# 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
+  ALIAS_FOR_FIND = :_original_find_before_arext
+
+  def self.included( cl ) # :nodoc:
+    virtual_class = class << cl ; self ; end
+    if not virtual_class.ancestors.include?( self::ClassMethods )
+      cl.instance_eval "alias #{ALIAS_FOR_FIND} :find"
+      cl.extend( ClassMethods )
+      cl.send( :include, InstanceMethods )
+    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( *args ) # :nodoc:
+      results = self.send( ALIAS_FOR_FIND, *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 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 = self.send( includes )
+        association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
+        if association.nil? or (association.respond_to?( :empty? ) and association.empty?)
+          [ get_class.call( includes ).columns.map{ '' } ]
+        else
+          [ *association.to_csv_data ]
+        end
+      when Array
+        siblings = []
+        includes.each do |association_name|
+          association = self.send( association_name )
+          association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
+          if association.nil? or (association.respond_to?( :empty? ) and association.empty?)
+            association_data = [ get_class.call( association_name ).columns.map{ '' }  ]
+          else
+            association_data = association.to_csv_data
+          end
+
+          if siblings.empty?
+            siblings.push( *association_data )
+          else
+            temp = []
+            association_data.each do |assoc_csv|
+              siblings.each do |sibling|
+                temp.push( sibling + assoc_csv )
+              end
+            end
+            siblings = temp            
+          end
+        end
+        siblings
+      when Hash
+        sorted_includes = includes.sort_by{ |k| k.to_s }
+        siblings = []
+        sorted_includes.each do |(association_name,options)|
+          association = self.send( association_name )
+          association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
+          if association.nil? or (association.respond_to?( :empty ) and association.empty?)
+            association_data = [ get_class.call( association_name ).columns.map{ '' }  ]
+          else
+            association_data = association.to_csv_data( options )
+          end
+
+          if siblings.empty?
+            siblings.push( *association_data )
+          else
+            temp = []
+            association_data.each do |assoc_csv|
+              siblings.each do |sibling|
+                temp.push( sibling + assoc_csv )
+              end
+            end
+            siblings = temp            
+          end
+        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