ardumper 1.0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Blythe Dunham
+
+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,80 @@
+AR DUMP HER!!!!!
+
+Project Full Name:  ArDumper
+Submitted Description: ArDumper is designed to dump volume rails activerecord data to a file in chunks. 
+
+Options include:
+* paginating arguments to control page size
+* finder options to provide control over the data set dumped
+* field/method options provide control over content dumped for each activerecord.
+
+Current supported file types are csv, xml and yaml.
+
+Other features include:
+* send_file support for ActiveController to send the file
+
+
+
+#############################################################################
+    ArDumper
+   ############################################################################ 
+    Formats ActiveRecord data in chunks and dumps it to a file, temporary file, or string. Specify the page_size used to paginate
+    records and flush files. 
+   
+    SPECIFY OUTPUT
+    * <tt>:filename</tt> - the name of the file to create. By default will create a file based on the timestamp.
+    * <tt>:file_extension</tt> - appends file extension unless one exists in file name
+    * <tt>:only</tt> - a list of the attributes to be included. By default, all column_names are used.
+    * <tt>:except</tt> - a list of the attributes to be excluded. By default, all column_names are used. This option is not available if +:only+ is used
+    * <tt>:methods</tt> - a list of the methods to be called on the object
+    * <tt>:procs</tt> - hash of header name to Proc object 
+    
+    FINDER METHODS
+    * <tt>:find</tt> - a map of the finder options passed to find. For example, + {:conditions => ['hairy = ?', 'of course'], :include => :rodents} +
+   
+    FORMAT HEADER
+    * <tt>:header</tt> - when a hash is specified, maps the field name to the header name. For example {:a => 'COL A', :b => 'COL B'} would print 'COL A', 'COL B'
+      when an array is specified uses this instead of the fields
+      when true or by default prints the fields
+      when false does not include a header      
+    * <tt>:text_format</tt> - a string method such as :titleize, :dasherize, :underscore to format the on all the headers. If an attribute is :email_address and 
+               :titleize is chosen, then the Header value is "Email Address"
+               
+    * <tt>:root</tt> In xml, this is the name of the highest level list object. The plural of the class name is the default. For yml, this is the base name of the
+      the objects. Each record will be root_id. For example, contact_2348
+                   
+    FILENAME AND TARGET
+    <tt> :target_type</tt> The target_type for the data. Defaults to +:file+. 
+      * :string prints to string. Do not use with large data sets
+      * :tmp_file. Use a temporary file that is destroyed when the process exists
+      * :file. Use a standard file
+    <tt> :filename </tt> basename of the file. Defaults to random time based string for non-temporary files
+    <tt> :file_extension </tt> Extension (suffix) like .csv, .xml. Added only if the basename has no suffix. 
+     :file_extension is only available when +:target_type_type => :file+
+    <tt> :file_path </tt> path or directory of the file. Defaults to dumper_file_path or temporary directories                        
+                         
+    Specify which attributes to include and exclude
+      Girlfriend.dumper :yml, :only => [:name, :rating]
+      
+      Boyfriend.dumper :csv, :except => [:personality]
+      
+      
+    Use :methods to include methods on the record
+    
+      BigOle.dumper :csv, :methods => [:age, :favorite_food]
+      Output..
+      ..other attributes.., 25, doughnuts
+                                        
+    To call any Proc's on the object(s) use :procs. All options are availabe to the process including
+      record - the active record
+      result_set - the current result set
+      counter - the number of the record
+      page_num - the page number
+      target - the file/string target  
+      proc = Proc.new { |options| options[:record].rating > 8 ? 'HIGHLY RATED' ? 'AVERAGE'}
+      Girlfriend.dumper :xml, :procs => {'my_rating' => proc}
+   
+      <girlfriend>
+          ... other attributes and methods ...
+        <my_rating>HIGHLY RATED</my_rating>
+      </girlfriend>

data/Rakefile

@@ -0,0 +1,79 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+PKG_NAME           = "ardumper"
+PKG_VERSION        = "1.0.1.1"
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = "ardumper"
+
+spec = Gem::Specification.new do |s|
+  s.name            = PKG_NAME
+  s.version         = PKG_VERSION
+  s.platform        = Gem::Platform::RUBY
+  s.summary         = "Provides developers with the ability to define any dependencies on external plugins directly from within another plugin."
+  s.files           = FileList["{lib,tasks}/**/*"].to_a + %w(init.rb LICENSE Rakefile README)
+  s.require_path    = "lib"
+  s.autorequire     = PKG_NAME
+  s.has_rdoc        = true
+  s.test_files      = nil#Dir["test/**/*_test.rb"]
+  s.add_dependency    "rails", ">= 1.2.0"
+ 
+  s.author          = "Blythe Dunham"
+  s.email           = "blythe@spongecell.com"
+  s.homepage        = "http://spongetech.wordpress.com/"
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the ar_dumper plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << '.\lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the ar_test plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ArP'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+ 
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do
+  #Rake::SshDirPublisher.new("spongecell.com", "/var/home/#{PKG_NAME}", "rdoc").upload
+  Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload
+end
+ 
+desc "Publish the API docs and gem"
+task :publish => [:pdoc, :release]
+
+
+
+desc "Publish the release files to RubyForge"
+task :release => [:gem, :package] do
+  require 'rubyforge'
+ 
+  options = {"cookie_jar" => RubyForge::COOKIE_F}
+  options["password"] = ENV["RUBY_FORGE_PASSWORD"] if ENV["RUBY_FORGE_PASSWORD"]
+  ruby_forge = RubyForge.new
+  ruby_forge.login
+ 
+  %w( gem tgz zip ).each do |ext|
+    file = "pkg/#{PKG_FILE_NAME}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+ 
+    ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
+  end
+end

data/init.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/lib/ar_dumper'
+
+

data/lib/ar_dumper.rb

@@ -0,0 +1,4 @@
+require 'ar_dumper_base'
+require 'ar_dumper_active_record'
+require 'ar_dumper_controller'
+

data/lib/ar_dumper_active_record.rb

@@ -0,0 +1,92 @@
+#############################################################################
+  # ArDumper
+  ############################################################################# 
+  # Formats ActiveRecord data in chunks and dumps it to a file, temporary file, or string. Specify the page_size used to paginate
+  # records and flush files. 
+  #
+  # SPECIFY OUTPUT
+  # * <tt>:filename</tt> - the name of the file to create. By default will create a file based on the timestamp.
+  # * <tt>:file_extension</tt> - appends file extension unless one exists in file name
+  # * <tt>:only</tt> - a list of the attributes to be included. By default, all column_names are used.
+  # * <tt>:except</tt> - a list of the attributes to be excluded. By default, all column_names are used. This option is not available if +:only+ is used
+  # * <tt>:methods</tt> - a list of the methods to be called on the object
+  # * <tt>:procs</tt> - hash of header name to Proc object 
+  # 
+  # FINDER METHODS
+  # * <tt>:find</tt> - a map of the finder options passed to find. For example, + {:conditions => ['hairy = ?', 'of course'], :include => :rodents} +
+  #
+  # FORMAT HEADER
+  # * <tt>:header</tt> - when a hash is specified, maps the field name to the header name. For example {:a => 'COL A', :b => 'COL B'} would print 'COL A', 'COL B'
+  #   when an array is specified uses this instead of the fields
+  #   when true or by default prints the fields
+  #   when false does not include a header      
+  # * <tt>:text_format</tt> - a string method such as :titleize, :dasherize, :underscore to format the on all the headers. If an attribute is :email_address and 
+  #            :titleize is chosen, then the Header value is "Email Address"
+  #            
+  # * <tt>:root</tt> In xml, this is the name of the highest level list object. The plural of the class name is the default. For yml, this is the base name of the
+  #   the objects. Each record will be root_id. For example, contact_2348
+  #                
+  # FILENAME AND TARGET
+  # <tt> :target_type</tt> The target_type for the data. Defaults to +:file+. 
+  #   * :string prints to string. Do not use with large data sets
+  #   * :tmp_file. Use a temporary file that is destroyed when the process exists
+  #   * :file. Use a standard file
+  # <tt> :filename </tt> basename of the file. Defaults to random time based string for non-temporary files
+  # <tt> :file_extension </tt> Extension (suffix) like .csv, .xml. Added only if the basename has no suffix. 
+  #  :file_extension is only available when +:target_type_type => :file+
+  # <tt> :file_path </tt> path or directory of the file. Defaults to dumper_file_path or temporary directories                        
+  #                      
+  # Specify which attributes to include and exclude
+  #   Girlfriend.dumper :yml, :only => [:name, :rating]
+  #   
+  #   Boyfriend.dumper :csv, :except => [:personality]
+  #   
+  #   
+  # Use :methods to include methods on the record
+  # 
+  #   BigOle.dumper :csv, :methods => [:age, :favorite_food]
+  #   Output..
+  #   ..other attributes.., 25, doughnuts
+  #                                     
+  # To call any Proc's on the object(s) use :procs. All options are availabe to the process including
+  #   record - the active record
+  #   result_set - the current result set
+  #   counter - the number of the record
+  #   page_num - the page number
+  #   target - the file/string target  
+  #   proc = Proc.new { |options| options[:record].rating > 8 ? 'HIGHLY RATED' ? 'AVERAGE'}
+  #   Girlfriend.dumper :xml, :procs => {'my_rating' => proc}
+  #
+  #   <girlfriend>
+  #     # ... other attributes and methods ...
+  #     <my_rating>HIGHLY RATED</my_rating>
+  #   </girlfriend>
+
+
+
+class ActiveRecord::Base
+  def self.to_csv(options={})
+    dump_to_string :csv, options
+  end
+  
+  def self.dump_to_yaml(options={})
+    dumper :yml, options
+  end
+ 
+  #dump to specified format
+  def self.dumper(format, options={})
+    ArDumper.new(self, options).dump(format)
+  end
+  
+  #dump to string
+  def self.dumper_to_string(format, options={})
+    dumper(format, options.update({:target_type => :string}))
+  end
+  
+  #dump_him dump_her and dump_em for fun
+  class << self
+    %w( dump_her dump_him dump_em ).each {|meth| alias_method meth, :dumper}
+  end
+end
+
+

data/lib/ar_dumper_base.rb

@@ -0,0 +1,465 @@
+   
+ 
+require 'csv'
+
+
+class ArDumperException < Exception
+end
+
+
+  #############################################################################
+  # ArDumper
+  ############################################################################# 
+  # Formats ActiveRecord data in chunks and dumps it to a file, temporary file, or string
+  #
+  # 
+  # * <tt>:filename</tt> - the name of the file to create. By default will create a file based on the timestamp.
+  # * <tt>:file_extension</tt> - appends file extension unless one exists in file name
+  
+  # * <tt>:only</tt> - a list of the attributes to be included. By default, all column_names are used.
+  # * <tt>:except</tt> - a list of the attributes to be excluded. By default, all column_names are used. This option is not available if +:only+ is used
+  # * <tt>:methods</tt> - a list of the methods to be called on the object
+  # * <tt>:procs</tt> - hash of header name to Proc object 
+  # * <tt>:find</tt> - a map of the finder options passed to find. For example, + {:conditions => ['hairy = ?', 'of course'], :include => :rodents} +
+  #
+  # * <tt>:header</tt> - when a hash is specified, maps the field name to the header name. For example {:a => 'COL A', :b => 'COL B'} would print 'COL A', 'COL B'
+  #                      when an array is specified uses this instead of the fields
+  #                      when true or by default prints the fields
+  #                      when false does not include a header      
+  # * <tt>:text_format</tt> - a string method such as :titleize, :dasherize, :underscore to format the on all the headers. If an attribute is :email_address and 
+  #            :titleize is chosen, then the Header value is "Email Address"
+  #            
+  # * <tt>:root</tt> In xml, this is the name of the highest level list object. The plural of the class name is the default. For yml, this is the base name of the
+  #   the objects. Each record will be root_id. For example, contact_2348
+  #                      
+ # Filename and target options
+  # <tt> :target_type</tt> The target_type for the data. Defaults to +:file+. 
+  #   * :string prints to string. Do not use with large data sets
+  #   * :tmp_file. Use a temporary file that is destroyed when the process exists
+  #   * :file. Use a standard file
+  # <tt> :filename </tt> basename of the file. Defaults to random time based string for non-temporary files
+  # <tt> :file_extension </tt> Extension (suffix) like .csv, .xml. Added only if the basename has no suffix. 
+  #  :file_extension is only available when +:target_type_type => :file+
+  # <tt> :file_path </tt> path or directory of the file. Defaults to dumper_file_path or temporary directories           
+  #                     
+  #                      
+  # Use :methods to include methods on the record
+  # 
+  # BigOle.dumper :csv, :methods => [:age, :favorite_food]
+  # ..other attributes.., 25, doughnuts
+  #                                     
+  # To call any Proc's on the object(s) use :procs. All options are availabe to the process including
+  #   record - the active record
+  #   result_set - the current result set
+  #   counter - the number of the record
+  #   page_num - the page number
+  #   target - the file/string target  
+  
+  #   proc = Proc.new { |options| options[:record].rating > 8 ? 'HIGHLY RATED' ? 'AVERAGE'}
+  #   Girlfriend.dumper :xml, :procs => {'my_rating' => proc}
+  #
+  #   <girlfriend>
+  #     # ... other attributes and methods ...
+  #     <my_rating>HIGHLY RATED</my_rating>
+  #   </girlfriend>
+  #
+class ArDumper 
+
+  cattr_accessor :dumper_page_size #default page size
+  @@dumper_page_size ||= 50
+  
+  cattr_accessor :dumper_file_path #default file path
+  @@dumper_file_path ||= ENV['TMPDIR']||ENV['TMP']||ENV['TEMP']||'.'
+  
+  cattr_accessor :dumper_tmp_file_basename #default basename of temporary files
+  @@dumper_tmp_file_basename ||= 'ardumper'
+  
+  cattr_accessor :csv_writer #default to faster csv if it is available
+
+
+  attr_reader :fields
+  attr_reader :klass
+  attr_reader :options
+  
+  def initialize(klass, dump_options={})
+    @klass = klass
+    @options = dump_options
+    build_attribute_list
+    
+    unless options[:text_format].nil? || String.new.respond_to?(options[:text_format])
+      raise ArDumperException.new("Invalid value for option :text_format #{options[:text_format]}")
+    end
+  end
+  
+  # build a list of attributes, methods and procs
+  def build_attribute_list#:nodoc:
+    if options[:only]
+      options[:attributes] = Array(options[:only])
+    else
+      options[:attributes] = @klass.column_names - Array(options[:except]).collect { |e| e.to_s }
+    end
+      
+    options[:attributes] = options[:attributes].collect{|attr| "#{attr}"}  
+    options[:methods] = options[:methods].is_a?(Hash) ? options[:methods].values : Array(options[:methods])
+    
+    #if procs are specified as an array separate the headers(keys) from the procs(values)
+    if options[:procs].is_a?(Hash)
+      options[:proc_headers]= options[:procs].keys
+      options[:procs]= options[:procs].values
+    else
+      options[:procs] = Array(options[:procs])
+      options[:proc_headers]||= Array.new
+      0.upto(options[:procs].size - options[:proc_headers].size - 1) {|idx| options[:proc_headers] << "proc_#{idx}" }
+    end
+    
+  end
+  
+
+  
+ 
+  def dump(format)
+    case format.to_sym
+      when :csv
+        dump_to_csv
+        
+      when :xml
+        dump_to_xml
+        
+      when :yaml, :fixture, :yml
+        dump_to_fixture
+        
+      else
+        raise ArDumperException.new("Unknown format #{format}. Please specify :csv, :xml, or :yml ")
+    end
+  end
+  
+  
+  # Wrapper around the outside of dumper
+  # See options in dumper
+  def dumper(file_extension=nil, header = nil, footer = nil, &block)
+    
+    options[:counter] = -1
+    begin
+      #get the file parameters
+      target = prepare_target(file_extension)
+      target << header if header
+      ArDumper.paginate_dump_records(@klass, @options) do |records, page_num|
+      
+        #save state on options to make it accessible by
+        #class and procs
+        options[:result_set] = records
+        options[:page_num] = page_num
+        
+        records.each do |record| 
+          options[:record] = record
+          yield record
+        end
+        
+        #flush after each set
+        target.flush if target.respond_to?(:flush)
+      end
+      target << footer if footer
+      
+    #final step close the options[:target]
+    ensure
+      target.close if target && target.respond_to?(:close)
+    end
+
+    options[:full_file_name]||target
+  end
+  
+  #collect the record data into an array
+  def dump_record(record)
+    record_values = @options[:attributes].inject([]){|values, attr| values << record["#{attr}"]; values }
+    record_values = @options[:methods].inject(record_values) {|values, method| values << record.send(method); values }
+    record_values = @options[:procs].inject(record_values){|values, proc| values << proc.call(options); values }
+    record_values
+  end
+  
+
+  #############################################################################
+  # XML Dumper
+  ############################################################################# 
+  #
+  # Dumps the data to an xml file
+  # 
+  # Using the ActiveRecord version of dumper so we CANNOT specify fields that are not attributes
+  # 
+  # In addition to options listed in +dumper+:
+  # * <tt>:xml</tt> - xml options for ActiveRecord .to_xml
+  def dump_to_xml
+  
+    #preserve the original skip instruct
+    skip_instruct = @options[:skip_instruct].is_a?(TrueClass)
+    
+    #use the fields if :only is not specified in the xml options
+    xml_options ={:only => @options[:only],
+                  :except => @options[:except],
+                  :methods => @options[:methods],
+                  :procs => @options[:procs]
+    }
+    
+    xml_options.update(@options[:xml]) if @options[:xml]
+
+    #do not instruct for each set
+    xml_options[:skip_instruct] = true
+    xml_options[:indent]||=2
+    xml_options[:margin] = xml_options[:margin].to_i + 1
+    
+    #set the variable on the options
+    options[:xml] = xml_options
+    
+    
+    #builder for header and footer
+    builder_options = {
+      :margin => xml_options[:margin] - 1,
+      :indent => xml_options[:indent]
+    }
+    
+    options[:root] = (options[:root] || @klass.to_s.underscore.pluralize).to_s
+
+    
+    #use the builder to make sure we are indented properly
+    builder = Builder::XmlMarkup.new(builder_options.clone)
+    builder.instruct! unless skip_instruct
+    builder << "<#{options[:root]}>\n"
+    header = builder.target!
+    
+    #get the footer. Using the builder will make sure we are indented properly
+    builder = Builder::XmlMarkup.new(builder_options)
+    builder << "</#{options[:root]}>"
+    footer = builder.target!
+    
+    dumper(:xml, header, footer) do |record| 
+      options[:target] << record.to_xml(xml_options.dup)
+    end
+  end
+  
+  #############################################################################
+  # Yaml/Fixture Dumper
+  ############################################################################# 
+  # dumps the data to a fixture file
+  # In addition to options listed in +dumper+:
+  # <tt>:root</tt> Basename of the record. Defaults to the class name so each record is named customer_1
+  def dump_to_fixture
+    basename = @options[:root]||@klass.table_name.singularize
+    header_list = build_header_list
+
+    # doctor the yaml a bit to print the hash header at the top
+    # instead of each record
+    dumper(:yml, "---\s") do |record|
+      record_data = Hash.new
+      dump_record(record).each_with_index{|field, idx| record_data[header_list[idx].to_s] = field.to_s }
+      options[:target] << {"#{basename}_#{record.id}" => record_data}.to_yaml.gsub(/^---\s\n/, "\n")
+    end
+  end
+  
+  
+  
+  #############################################################################
+  # CSV DUMPER
+  ############################################################################# 
+  #
+  # Dump csv data
+  # 
+  # * <tt>:csv</tt> - any options to pass to csv parser. 
+  #   :col_sep Example + :csv => {:col_sep => "\t"} +
+  #   :row_sep Row seperator
+  # * <tt>:page_size</tt> - the page size to use. Defaults to dumper_page_size or 50
+  def dump_to_csv
+    header = nil
+    @options[:csv]||={}
+    
+    if !@options[:header].is_a?(FalseClass)
+      header_list = build_header_list
+      #print the header unless set to false
+      header = write_csv_row(header_list)
+    end
+    
+    dumper(:csv, header) do |record|
+      options[:target] << write_csv_row(dump_record(record))
+    end
+  end
+  
+  # Write out the csv row using the selected csv writer
+  def write_csv_row(row_data, header_list=[])#:nodoc: 
+    if csv_writer == :faster
+      ::FasterCSV::Row.new(header_list, row_data).to_csv(@options[:csv])
+    else
+      ::CSV.generate_line(row_data, @options[:csv][:col_sep], @options[:csv][:row_sep]) + (@options[:csv][:row_sep]||"\n")
+    end
+  end
+  
+  #Try to use the FasterCSV if it exists
+  #otherwise use csv
+  def csv_writer #:nodoc:
+    unless @@csv_writer
+      @@csv_writer = :faster
+      begin 
+        require 'faster_csv'
+        ::FasterCSV
+      rescue Exception => exc
+        @@csv_writer = :normal
+      end
+    end
+    @@csv_writer
+  end
+  
+  # Returns an array with the header names
+  # This will be in the same order as the data returned by dump_record
+  # attributes + methods + procs
+  # 
+  # <tt>:header</tt> The header defaults to the attributes and method names. When set
+  #  to false no header is specified
+  #   * +hash+ A map from attribute or method name to Header column name
+  #   * +array+ A list in the same order that is used to display record data
+  #   
+  # <tt>:procs</tt> If a hash, then the keys are the names. If an array, then use proc_1, proc_2, etc
+  # <tt>:text_format</tt> Format names with a text format such as +:titlieze+, +:dasherize+, +:underscore+
+  def build_header_list#:nodoc:
+  
+    header_options = options[:header]
+    columns = @options[:attributes] + @options[:methods]
+    header_names = 
+      if header_options.is_a?(Hash)
+        header_options.symbolize_keys!
+        
+        #Get the header for each attribute and method
+        columns.collect{|field|(header_options[field.to_sym]||field).to_s}
+        
+      #ordered by attributes, methods, then procs
+      elsif header_options.is_a?(Array)
+        header_names = header_options
+        header_names.concat(columns[header_options.length..-1]) if header_names.length < columns.length
+        
+      #default to column names 
+      else
+        columns
+      end
+    
+    #add process names
+    header_names.concat(options[:proc_headers])
+    
+    #format names with a text format such as titlieze, dasherize, underscore
+    header_names.collect!{|n| n.to_s.send(options[:text_format])} if options[:text_format]
+    
+    header_names
+  end
+    
+  
+
+  
+    
+  # Create the options[:target](file) based on these options. The options[:target] must respond to <<
+  # Current options[:target]s are :string, :file, :tempfile
+  #
+  # <tt> :target_type</tt> The options[:target] for the data. Defaults to +:file+
+  #   * :string prints to string. Do not use with large data sets
+  #   * :tmp_file. Use a temporary file that is destroyed when the process exists
+  #   * :file. Use a standard file
+  # <tt> :filename </tt> basename of the file. Defaults to random time based string for non-temporary files
+  # <tt> :file_extension </tt> Extension (suffix) like .csv, .xml. Added only if the basename has no suffix. 
+  #  :file_extension is only available when +:target_type_type => :file+
+  # <tt> :file_path </tt> path or directory of the file. Defaults to dumper_file_path or temporary directories
+ 
+  def prepare_target(file_extension = nil)
+    
+    options[:target] = case options[:target_type]
+      #to string option dumps to a string instead of a file
+      when :string
+        String.new
+        
+      #use a temporary file
+      #open a temporary file with the basename specified by filename
+      #defaults to the value of one of the environment variables TMPDIR, TMP, or TEMP
+      when :tmp_file
+
+        Tempfile.open(options[:filename]||(@@dumper_tmp_file_basename+@klass.name.downcase), 
+                      options[:file_path]||@@dumper_file_path)
+                      
+      #default to a real file                
+      else
+        extension = options[:file_extension]||file_extension
+        mode = options[:append_to_file].is_a?(TrueClass)? 'a' : 'w'
+        filename = options[:filename]||"#{@@dumper_tmp_file_basename}.#{@klass.name.downcase}.#{Time.now.to_f.to_s}.#{extension}"
+        
+        #append an extension unless one already exists
+        filename += ".#{extension}" if extension && !filename =~ /\.\w*$/
+        
+        #get the file path if the filename does not contain one
+        if File.basename(filename) == filename
+          path = options[:file_path]||@@dumper_file_path 
+          filename = File.join(path, filename) unless path.blank?
+        end
+
+        
+        File.open(filename, mode)
+     end
+     
+    options[:full_file_name] = options[:target].path if options[:target].respond_to?(:path)
+    options[:target]
+  end
+  
+  
+    
+  #############################################################################
+  # Pagination Helpers... OR YOU COULD INSTALL paginate_find plugin!
+  ############################################################################# 
+  #
+  #
+  # Quick and dirty paginate to loop thru the records page by page
+  # Options are:
+  # * <tt>:find</tt> - a map of the finder options passed to find. For example, + {:conditions => ['hairy = ?', 'of course'], :include => :rodents} +
+  # * <tt>:page_size</tt> - the page size to use. Defaults to dumper_page_size or 50. Set to false to disable pagination
+  # 
+  def self.paginate_dump_records(klass, options={}, &block)
+    finder_options = (options[:find]||{}).clone
+    
+    #pagination is not needed when :page_size => false
+    if options[:page_size].is_a?(FalseClass)
+      yield klass.find(:all, finder_options), 0
+      return
+    end
+    
+    options[:page_size]||= dumper_page_size
+    
+    #limit becomes the maximum amount of records to pull
+    max_records = finder_options[:limit]
+    page_num = 0
+    finder_options[:limit] = compute_page_size(max_records, page_num, options[:page_size])
+    records = []
+    while (finder_options[:limit] > 0 && (page_num == 0 || records.length == options[:page_size]))      
+      records = klass.find :all, finder_options.update(:offset => page_num * options[:page_size])
+      
+      yield records, page_num
+      page_num = page_num + 1
+      
+      #calculate the limit if an original limit (max_records) was set
+      finder_options[:limit] = compute_page_size(max_records, page_num, options[:page_size])
+    end
+  end
+  
+  def self.compute_page_size(max_records, page_num, page_size)#:nodoc:
+    max_records ? [(max_records - (page_num * page_size)), page_size].min : page_size
+  end
+  
+  # Quick and dirty paginate to loop thru each page
+  # Options are:
+  # * <tt>:find</tt> - a map of the finder options passed to find. For example, + {:conditions => ['hairy = ?', 'of course'], :include => :rodents} +
+  # * <tt>:page_size</tt> - the page size to use. Defaults to dumper_page_size or 50. Set to false to disable pagination
+  def self.paginate_each_record(klass, options={}, &block)
+    counter = -1
+    paginate_dump_records(klass, options) do |records, page_num|
+      records.each do |record| 
+        yield record, (counter +=1)
+      end
+    end
+  end                        
+end
+
+
+
+
+
+
+

data/lib/ar_dumper_controller.rb

@@ -0,0 +1,51 @@
+class ActionController::Base
+
+  #Change to :file to use regular files
+  cattr_accessor :dumper_target
+  @@dumper_target = :tmp_file
+  
+  
+  # send a dumped file
+  # Options are:
+  # * <tt>klass</tt> - the active record to use. Animal or Contact or Author or Tumama
+  # * <tt>send_options</tt> send_options include send_file options such as +:type+ and +:disposition+
+  # * <tt>dump_options</tt> options to send to the dumper. These options are in ArDumper.dump_to_csv
+  # * <tt>:find</tt> - a map of the finder options passed to find. For example, + {:conditions => ['features.hair = ?', 'blonde'], :include => :features} +
+  # * <tt>:header</tt> - when a hash is specified, maps the field name to the header name. For example {:a => 'COL A', :b => 'COL B'} would print 'COL A', 'COL B'
+  #                      when an array is specified uses this instead of the fields
+  #                      when true or by default prints the fields
+  #                      when false does not include a header
+  # * <tt>:csv</tt> - any options to pass to csv parser. Example + :csv => {:col_sep => "\t"} +
+  # * <tt>:page_size</tt> - the page size to use. Defaults to dumper_page_size or 50
+  def send_file_dump(format, klass, send_options={}, dump_options={})
+
+    #use the base name of the dump file name if specified
+    send_options[:filename] ||= File.basename(dump_options[:filename]) if dump_options[:filename]
+    
+    #never delete the file
+    dump_options[:delete_file] = false
+    
+    #use temporary files unless otherwise specified
+    dump_options[:target_type]||= @@dumper_target
+        
+    #send_options[:type] = 'application/xml; charset=utf-8;'
+    if send_options[:type].nil? && send_options[:disposition] == 'inline'
+      send_options[:type] =
+        case format.to_sym
+          when :xml then 'application/xml; charset=utf-8;'
+          when :csv then 'application/csv; charset=utf-8;'
+          when :yml then 'text/html; charset=utf-8;'
+        end
+
+    end
+
+    target = klass.dumper(format, dump_options)
+    
+    if dump_options[:target_type] == :string
+      send_data(target, send_options)
+    else
+      send_file(target, send_options)
+    end
+  end
+ 
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: ardumper
+version: !ruby/object:Gem::Version 
+  version: 1.0.1.1
+date: 2007-08-09 00:00:00 -07:00
+summary: Provides developers with the ability to define any dependencies on external plugins directly from within another plugin.
+require_paths: 
+- lib
+email: blythe@spongecell.com
+homepage: http://spongetech.wordpress.com/
+rubyforge_project: 
+description: 
+autorequire: ardumper
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Blythe Dunham
+files: 
+- lib/ar_dumper.rb
+- lib/ar_dumper_active_record.rb
+- lib/ar_dumper_base.rb
+- lib/ar_dumper_controller.rb
+- init.rb
+- LICENSE
+- Rakefile
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: