Feature #5638 » bundler-full-r6631.patch
| Gemfile | ||
|---|---|---|
|
source :rubygems
|
||
|
source :rubyforge
|
||
|
source :gemcutter
|
||
|
gem 'bundler', '~> 1.0.0'
|
||
|
gem 'rails', '2.3.11'
|
||
|
gem 'rack' , '~> 1.1.1'
|
||
|
gem 'i18n', '>= 0.4.2'
|
||
|
gem 'rubytree', '0.5.2', :require => 'tree'
|
||
|
gem 'coderay', '~> 0.9.7'
|
||
|
# Please uncomment lines for your databases.
|
||
|
# Alternatively you may want to add these lines to specific groups below.
|
||
|
# gem 'sqlite3-ruby', :require => 'sqlite3' # for SQLite 3
|
||
|
# gem 'mysql' # MySQL
|
||
|
# gem 'pg' # PostgreSQL
|
||
|
gem 'pg'
|
||
|
group :development do
|
||
|
end
|
||
|
group :production do
|
||
|
end
|
||
|
group :test do
|
||
|
gem 'shoulda'
|
||
|
gem 'mocha'
|
||
|
gem 'edavis10-object_daddy', :require => 'object_daddy'
|
||
|
end
|
||
|
# Load plugins Gemfiles
|
||
|
Dir.glob(File.join(File.dirname(__FILE__), %w(vendor plugins * Gemfile))) do |file|
|
||
|
puts "Loading #{file} ..."
|
||
|
instance_eval File.read(file)
|
||
|
end
|
||
| config/boot.rb | ||
|---|---|---|
|
class Boot
|
||
|
def run
|
||
|
load_initializer
|
||
|
Rails::Initializer.class_eval do
|
||
|
def load_gems
|
||
|
@bundler_loaded ||= Bundler.require :default, Rails.env
|
||
|
end
|
||
|
end
|
||
|
Rails::Initializer.run(:set_load_path)
|
||
|
end
|
||
|
end
|
||
| ... | ... | |
|
end
|
||
|
end
|
||
|
# TODO: Workaround for #7013 to be removed for 1.2.0
|
||
|
# Loads i18n 0.4.2 before Rails loads any more recent gem
|
||
|
# 0.5.0 is not compatible with the old interpolation syntax
|
||
|
# Plugins will have to migrate to the new syntax for 1.2.0
|
||
|
require 'rubygems'
|
||
|
begin
|
||
|
gem 'i18n', '0.4.2'
|
||
|
rescue Gem::LoadError => load_error
|
||
|
$stderr.puts %(Missing the i18n 0.4.2 gem. Please `gem install -v=0.4.2 i18n`)
|
||
|
exit 1
|
||
|
end
|
||
|
# All that for this:
|
||
|
Rails.boot!
|
||
| config/environment.rb | ||
|---|---|---|
|
# It will automatically turn deliveries on
|
||
|
config.action_mailer.perform_deliveries = false
|
||
|
config.gem 'rubytree', :lib => 'tree'
|
||
|
config.gem 'coderay', :version => '~>0.9.7'
|
||
|
# Load any local configuration that is kept out of source control
|
||
|
# (e.g. gems, patches).
|
||
|
if File.exists?(File.join(File.dirname(__FILE__), 'additional_environment.rb'))
|
||
| config/preinitializer.rb | ||
|---|---|---|
|
begin
|
||
|
require "rubygems"
|
||
|
require "bundler"
|
||
|
rescue LoadError
|
||
|
raise "Could not load the bundler gem. Install it with `gem install bundler`."
|
||
|
end
|
||
|
if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.25")
|
||
|
raise RuntimeError, "Your bundler version is too old for Rails 2.3." +
|
||
|
"Run `gem install bundler` to upgrade."
|
||
|
end
|
||
|
begin
|
||
|
# Set up load paths for all bundled gems
|
||
|
ENV["BUNDLE_GEMFILE"] = File.expand_path("../../Gemfile", __FILE__)
|
||
|
Bundler.setup
|
||
|
rescue Bundler::GemNotFound
|
||
|
raise RuntimeError, "Bundler couldn't find some gems." +
|
||
|
"Did you run `bundle install`?"
|
||
|
end
|
||
| Gemfile | ||
|---|---|---|
|
source :rubyforge
|
||
|
source :gemcutter
|
||
|
gem "ruby-openid"
|
||
|
gem 'bundler', '~> 1.0.0'
|
||
|
gem 'rails', '2.3.11'
|
||
|
gem 'rack' , '~> 1.1.1'
|
||
| ... | ... | |
|
gem 'rubytree', '0.5.2', :require => 'tree'
|
||
|
gem 'coderay', '~> 0.9.7'
|
||
|
# Please uncomment lines for your databases.
|
||
|
# Alternatively you may want to add these lines to specific groups below.
|
||
|
# gem 'sqlite3-ruby', :require => 'sqlite3' # for SQLite 3
|
||
|
# gem 'mysql' # MySQL
|
||
|
# gem 'pg' # PostgreSQL
|
||
|
gem 'pg'
|
||
|
group :development do
|
||
|
end
|
||
| ... | ... | |
|
end
|
||
|
group :test do
|
||
|
gem 'shoulda'
|
||
|
gem 'shoulda', '~> 2.10.3'
|
||
|
gem 'mocha'
|
||
|
gem 'edavis10-object_daddy', :require => 'object_daddy'
|
||
|
end
|
||
|
# Use the commented pure ruby gems, if you have not the needed prerequisites on
|
||
|
# board to compile the native ones. Note, that their use is discouraged, since
|
||
|
# their integration is propbably not that well tested and their are slower in
|
||
|
# orders of magnitude compared to their native counterparts. You have been
|
||
|
# warned.
|
||
|
#
|
||
|
platforms :mri do
|
||
|
group :mysql do
|
||
|
gem "mysql"
|
||
|
# gem "ruby-mysql"
|
||
|
end
|
||
|
group :mysql2 do
|
||
|
gem "mysql2"
|
||
|
end
|
||
|
group :postgres do
|
||
|
gem "pg", "~> 0.9.0"
|
||
|
# gem "postgres-pr"
|
||
|
end
|
||
|
group :sqlite do
|
||
|
gem "sqlite3-ruby", "< 1.3", :require => "sqlite3"
|
||
|
# please tell me, if you are fond of a pure ruby sqlite3 binding
|
||
|
end
|
||
|
end
|
||
|
platforms :jruby do
|
||
|
gem "jruby-openssl"
|
||
|
group :mysql do
|
||
|
gem "activerecord-jdbcmysql-adapter"
|
||
|
end
|
||
|
group :postgres do
|
||
|
gem "activerecord-jdbcpostgresql-adapter"
|
||
|
end
|
||
|
group :sqlite do
|
||
|
gem "activerecord-jdbcsqlite3-adapter"
|
||
|
end
|
||
|
end
|
||
|
# Load plugins Gemfiles
|
||
|
Dir.glob(File.join(File.dirname(__FILE__), %w(vendor plugins * Gemfile))) do |file|
|
||
|
puts "Loading #{file} ..."
|
||
| config/boot.rb | ||
|---|---|---|
|
def run
|
||
|
load_initializer
|
||
|
# This block was added for bundler support while following setup
|
||
|
# instructions from http://gembundler.com/rails23.html
|
||
|
Rails::Initializer.class_eval do
|
||
|
def load_gems
|
||
|
@bundler_loaded ||= Bundler.require :default, Rails.env
|
||
| config/environments/test.rb | ||
|---|---|---|
|
# Skip protect_from_forgery in requests http://m.onkey.org/2007/9/28/csrf-protection-for-your-existing-rails-application
|
||
|
config.action_controller.allow_forgery_protection = false
|
||
|
config.gem "shoulda", :version => "~> 2.10.3"
|
||
|
config.gem "edavis10-object_daddy", :lib => "object_daddy"
|
||
|
config.gem "mocha"
|
||
| Gemfile | ||
|---|---|---|
|
source :rubyforge
|
||
|
source :gemcutter
|
||
|
gem "ruby-openid"
|
||
|
gem 'bundler', '~> 1.0.0'
|
||
|
gem 'rails', '2.3.11'
|
||
|
gem 'rack' , '~> 1.1.1'
|
||
| ... | ... | |
|
gem 'edavis10-object_daddy', :require => 'object_daddy'
|
||
|
end
|
||
|
group :openid do
|
||
|
gem "ruby-openid", '~> 2.1.4', :require => 'openid'
|
||
|
end
|
||
|
# Use the commented pure ruby gems, if you have not the needed prerequisites on
|
||
|
# board to compile the native ones. Note, that their use is discouraged, since
|
||
| Gemfile | ||
|---|---|---|
|
gem "ruby-openid", '~> 2.1.4', :require => 'openid'
|
||
|
end
|
||
|
group :rmagick do
|
||
|
gem "rmagick", "~> 1.15.17"
|
||
|
end
|
||
|
# Use the commented pure ruby gems, if you have not the needed prerequisites on
|
||
|
# board to compile the native ones. Note, that their use is discouraged, since
|
||
|
# their integration is propbably not that well tested and their are slower in
|
||
| Gemfile | ||
|---|---|---|
|
end
|
||
|
group :mysql2 do
|
||
|
gem "mysql2"
|
||
|
gem "mysql2", "~> 0.2.7"
|
||
|
end
|
||
|
group :postgres do
|
||
| Gemfile | ||
|---|---|---|
|
# Load plugins Gemfiles
|
||
|
Dir.glob(File.join(File.dirname(__FILE__), %w(vendor plugins * Gemfile))) do |file|
|
||
|
puts "Loading #{file} ..."
|
||
|
puts "Loading #{file} ..." if $DEBUG # `ruby -d` or `bundle -v`
|
||
|
instance_eval File.read(file)
|
||
|
end
|
||
| Gemfile | ||
|---|---|---|
|
end
|
||
|
end
|
||
|
platforms :mingw do
|
||
|
group :mysql do
|
||
|
gem "mysql"
|
||
|
# gem "ruby-mysql"
|
||
|
end
|
||
|
group :postgres do
|
||
|
gem "pg", "~> 0.9.0"
|
||
|
# gem "postgres-pr"
|
||
|
end
|
||
|
group :sqlite do
|
||
|
gem "sqlite3-ruby", "< 1.3", :require => "sqlite3"
|
||
|
# please tell me, if you are fond of a pure ruby sqlite3 binding
|
||
|
end
|
||
|
end
|
||
|
platforms :jruby do
|
||
|
gem "jruby-openssl"
|
||
| Gemfile | ||
|---|---|---|
|
# gem "ruby-mysql"
|
||
|
end
|
||
|
## Add Windows support
|
||
|
## https://github.com/brianmario/mysql2/issues/8
|
||
|
## Getting mysql2 gem to work with Ruby on Rails 3.0 and Windows 7 64bit
|
||
|
## http://paul-wong-jr.blogspot.com/2011/06/getting-mysql2-gem-to-work-with-ruby-on.html
|
||
|
# group :mysql2 do
|
||
|
# gem "mysql2", "~> 0.2.7"
|
||
|
# end
|
||
|
group :postgres do
|
||
|
gem "pg", "~> 0.9.0"
|
||
|
# gem "postgres-pr"
|
||
| Gemfile | ||
|---|---|---|
|
gem "pg", "~> 0.9.0"
|
||
|
# gem "postgres-pr"
|
||
|
end
|
||
|
end
|
||
|
platforms :mri_18 do
|
||
|
group :sqlite do
|
||
|
gem "sqlite3-ruby", "< 1.3", :require => "sqlite3"
|
||
|
# please tell me, if you are fond of a pure ruby sqlite3 binding
|
||
|
end
|
||
|
end
|
||
|
platforms :mri_19 do
|
||
|
group :sqlite do
|
||
|
gem "sqlite3"
|
||
|
end
|
||
|
end
|
||
| Gemfile | ||
|---|---|---|
|
end
|
||
|
end
|
||
|
# Load a "local" Gemfile
|
||
|
gemfile_local = File.join(File.dirname(__FILE__), "Gemfile.local")
|
||
|
if File.readable?(gemfile_local)
|
||
|
puts "Loading #{gemfile_local} ..." if $DEBUG
|
||
|
instance_eval(File.read(gemfile_local))
|
||
|
end
|
||
|
# Load plugins Gemfiles
|
||
|
Dir.glob(File.join(File.dirname(__FILE__), %w(vendor plugins * Gemfile))) do |file|
|
||
|
puts "Loading #{file} ..." if $DEBUG # `ruby -d` or `bundle -v`
|
||
| Gemfile | ||
|---|---|---|
|
gem 'shoulda', '~> 2.10.3'
|
||
|
gem 'mocha'
|
||
|
gem 'edavis10-object_daddy', :require => 'object_daddy'
|
||
|
platforms :mri_18 do gem 'ruby-debug' end
|
||
|
platforms :mri_19 do gem 'ruby-debug19', :require => 'ruby-debug' end
|
||
|
end
|
||
|
group :openid do
|
||
| Gemfile | ||
|---|---|---|
|
gem 'rubytree', '0.5.2', :require => 'tree'
|
||
|
gem 'coderay', '~> 0.9.7'
|
||
|
gem "fastercsv", "~> 1.5.0", :platforms => [:mri_18, :jruby, :mingw_18]
|
||
|
group :development do
|
||
|
end
|
||
| lib/faster_csv.rb | ||
|---|---|---|
|
#!/usr/local/bin/ruby -w
|
||
|
# = faster_csv.rb -- Faster CSV Reading and Writing
|
||
|
#
|
||
|
# Created by James Edward Gray II on 2005-10-31.
|
||
|
# Copyright 2005 Gray Productions. All rights reserved.
|
||
|
#
|
||
|
# See FasterCSV for documentation.
|
||
|
if RUBY_VERSION >= "1.9"
|
||
|
abort <<-VERSION_WARNING.gsub(/^\s+/, "")
|
||
|
Please switch to Ruby 1.9's standard CSV library. It's FasterCSV plus
|
||
|
support for Ruby 1.9's m17n encoding engine.
|
||
|
VERSION_WARNING
|
||
|
end
|
||
|
require "forwardable"
|
||
|
require "English"
|
||
|
require "enumerator"
|
||
|
require "date"
|
||
|
require "stringio"
|
||
|
#
|
||
|
# This class provides a complete interface to CSV files and data. It offers
|
||
|
# tools to enable you to read and write to and from Strings or IO objects, as
|
||
|
# needed.
|
||
|
#
|
||
|
# == Reading
|
||
|
#
|
||
|
# === From a File
|
||
|
#
|
||
|
# ==== A Line at a Time
|
||
|
#
|
||
|
# FasterCSV.foreach("path/to/file.csv") do |row|
|
||
|
# # use row here...
|
||
|
# end
|
||
|
#
|
||
|
# ==== All at Once
|
||
|
#
|
||
|
# arr_of_arrs = FasterCSV.read("path/to/file.csv")
|
||
|
#
|
||
|
# === From a String
|
||
|
#
|
||
|
# ==== A Line at a Time
|
||
|
#
|
||
|
# FasterCSV.parse("CSV,data,String") do |row|
|
||
|
# # use row here...
|
||
|
# end
|
||
|
#
|
||
|
# ==== All at Once
|
||
|
#
|
||
|
# arr_of_arrs = FasterCSV.parse("CSV,data,String")
|
||
|
#
|
||
|
# == Writing
|
||
|
#
|
||
|
# === To a File
|
||
|
#
|
||
|
# FasterCSV.open("path/to/file.csv", "w") do |csv|
|
||
|
# csv << ["row", "of", "CSV", "data"]
|
||
|
# csv << ["another", "row"]
|
||
|
# # ...
|
||
|
# end
|
||
|
#
|
||
|
# === To a String
|
||
|
#
|
||
|
# csv_string = FasterCSV.generate do |csv|
|
||
|
# csv << ["row", "of", "CSV", "data"]
|
||
|
# csv << ["another", "row"]
|
||
|
# # ...
|
||
|
# end
|
||
|
#
|
||
|
# == Convert a Single Line
|
||
|
#
|
||
|
# csv_string = ["CSV", "data"].to_csv # to CSV
|
||
|
# csv_array = "CSV,String".parse_csv # from CSV
|
||
|
#
|
||
|
# == Shortcut Interface
|
||
|
#
|
||
|
# FCSV { |csv_out| csv_out << %w{my data here} } # to $stdout
|
||
|
# FCSV(csv = "") { |csv_str| csv_str << %w{my data here} } # to a String
|
||
|
# FCSV($stderr) { |csv_err| csv_err << %w{my data here} } # to $stderr
|
||
|
#
|
||
|
class FasterCSV
|
||
|
# The version of the installed library.
|
||
|
VERSION = "1.5.0".freeze
|
||
|
|
||
|
#
|
||
|
# A FasterCSV::Row is part Array and part Hash. It retains an order for the
|
||
|
# fields and allows duplicates just as an Array would, but also allows you to
|
||
|
# access fields by name just as you could if they were in a Hash.
|
||
|
#
|
||
|
# All rows returned by FasterCSV will be constructed from this class, if
|
||
|
# header row processing is activated.
|
||
|
#
|
||
|
class Row
|
||
|
#
|
||
|
# Construct a new FasterCSV::Row from +headers+ and +fields+, which are
|
||
|
# expected to be Arrays. If one Array is shorter than the other, it will be
|
||
|
# padded with +nil+ objects.
|
||
|
#
|
||
|
# The optional +header_row+ parameter can be set to +true+ to indicate, via
|
||
|
# FasterCSV::Row.header_row?() and FasterCSV::Row.field_row?(), that this is
|
||
|
# a header row. Otherwise, the row is assumes to be a field row.
|
||
|
#
|
||
|
# A FasterCSV::Row object supports the following Array methods through
|
||
|
# delegation:
|
||
|
#
|
||
|
# * empty?()
|
||
|
# * length()
|
||
|
# * size()
|
||
|
#
|
||
|
def initialize(headers, fields, header_row = false)
|
||
|
@header_row = header_row
|
||
|
|
||
|
# handle extra headers or fields
|
||
|
@row = if headers.size > fields.size
|
||
|
headers.zip(fields)
|
||
|
else
|
||
|
fields.zip(headers).map { |pair| pair.reverse }
|
||
|
end
|
||
|
end
|
||
|
|
||
|
# Internal data format used to compare equality.
|
||
|
attr_reader :row
|
||
|
protected :row
|
||
|
### Array Delegation ###
|
||
|
extend Forwardable
|
||
|
def_delegators :@row, :empty?, :length, :size
|
||
|
|
||
|
# Returns +true+ if this is a header row.
|
||
|
def header_row?
|
||
|
@header_row
|
||
|
end
|
||
|
|
||
|
# Returns +true+ if this is a field row.
|
||
|
def field_row?
|
||
|
not header_row?
|
||
|
end
|
||
|
|
||
|
# Returns the headers of this row.
|
||
|
def headers
|
||
|
@row.map { |pair| pair.first }
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# :call-seq:
|
||
|
# field( header )
|
||
|
# field( header, offset )
|
||
|
# field( index )
|
||
|
#
|
||
|
# This method will fetch the field value by +header+ or +index+. If a field
|
||
|
# is not found, +nil+ is returned.
|
||
|
#
|
||
|
# When provided, +offset+ ensures that a header match occurrs on or later
|
||
|
# than the +offset+ index. You can use this to find duplicate headers,
|
||
|
# without resorting to hard-coding exact indices.
|
||
|
#
|
||
|
def field(header_or_index, minimum_index = 0)
|
||
|
# locate the pair
|
||
|
finder = header_or_index.is_a?(Integer) ? :[] : :assoc
|
||
|
pair = @row[minimum_index..-1].send(finder, header_or_index)
|
||
|
# return the field if we have a pair
|
||
|
pair.nil? ? nil : pair.last
|
||
|
end
|
||
|
alias_method :[], :field
|
||
|
|
||
|
#
|
||
|
# :call-seq:
|
||
|
# []=( header, value )
|
||
|
# []=( header, offset, value )
|
||
|
# []=( index, value )
|
||
|
#
|
||
|
# Looks up the field by the semantics described in FasterCSV::Row.field()
|
||
|
# and assigns the +value+.
|
||
|
#
|
||
|
# Assigning past the end of the row with an index will set all pairs between
|
||
|
# to <tt>[nil, nil]</tt>. Assigning to an unused header appends the new
|
||
|
# pair.
|
||
|
#
|
||
|
def []=(*args)
|
||
|
value = args.pop
|
||
|
|
||
|
if args.first.is_a? Integer
|
||
|
if @row[args.first].nil? # extending past the end with index
|
||
|
@row[args.first] = [nil, value]
|
||
|
@row.map! { |pair| pair.nil? ? [nil, nil] : pair }
|
||
|
else # normal index assignment
|
||
|
@row[args.first][1] = value
|
||
|
end
|
||
|
else
|
||
|
index = index(*args)
|
||
|
if index.nil? # appending a field
|
||
|
self << [args.first, value]
|
||
|
else # normal header assignment
|
||
|
@row[index][1] = value
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# :call-seq:
|
||
|
# <<( field )
|
||
|
# <<( header_and_field_array )
|
||
|
# <<( header_and_field_hash )
|
||
|
#
|
||
|
# If a two-element Array is provided, it is assumed to be a header and field
|
||
|
# and the pair is appended. A Hash works the same way with the key being
|
||
|
# the header and the value being the field. Anything else is assumed to be
|
||
|
# a lone field which is appended with a +nil+ header.
|
||
|
#
|
||
|
# This method returns the row for chaining.
|
||
|
#
|
||
|
def <<(arg)
|
||
|
if arg.is_a?(Array) and arg.size == 2 # appending a header and name
|
||
|
@row << arg
|
||
|
elsif arg.is_a?(Hash) # append header and name pairs
|
||
|
arg.each { |pair| @row << pair }
|
||
|
else # append field value
|
||
|
@row << [nil, arg]
|
||
|
end
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# A shortcut for appending multiple fields. Equivalent to:
|
||
|
#
|
||
|
# args.each { |arg| faster_csv_row << arg }
|
||
|
#
|
||
|
# This method returns the row for chaining.
|
||
|
#
|
||
|
def push(*args)
|
||
|
args.each { |arg| self << arg }
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# :call-seq:
|
||
|
# delete( header )
|
||
|
# delete( header, offset )
|
||
|
# delete( index )
|
||
|
#
|
||
|
# Used to remove a pair from the row by +header+ or +index+. The pair is
|
||
|
# located as described in FasterCSV::Row.field(). The deleted pair is
|
||
|
# returned, or +nil+ if a pair could not be found.
|
||
|
#
|
||
|
def delete(header_or_index, minimum_index = 0)
|
||
|
if header_or_index.is_a? Integer # by index
|
||
|
@row.delete_at(header_or_index)
|
||
|
else # by header
|
||
|
@row.delete_at(index(header_or_index, minimum_index))
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# The provided +block+ is passed a header and field for each pair in the row
|
||
|
# and expected to return +true+ or +false+, depending on whether the pair
|
||
|
# should be deleted.
|
||
|
#
|
||
|
# This method returns the row for chaining.
|
||
|
#
|
||
|
def delete_if(&block)
|
||
|
@row.delete_if(&block)
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# This method accepts any number of arguments which can be headers, indices,
|
||
|
# Ranges of either, or two-element Arrays containing a header and offset.
|
||
|
# Each argument will be replaced with a field lookup as described in
|
||
|
# FasterCSV::Row.field().
|
||
|
#
|
||
|
# If called with no arguments, all fields are returned.
|
||
|
#
|
||
|
def fields(*headers_and_or_indices)
|
||
|
if headers_and_or_indices.empty? # return all fields--no arguments
|
||
|
@row.map { |pair| pair.last }
|
||
|
else # or work like values_at()
|
||
|
headers_and_or_indices.inject(Array.new) do |all, h_or_i|
|
||
|
all + if h_or_i.is_a? Range
|
||
|
index_begin = h_or_i.begin.is_a?(Integer) ? h_or_i.begin :
|
||
|
index(h_or_i.begin)
|
||
|
index_end = h_or_i.end.is_a?(Integer) ? h_or_i.end :
|
||
|
index(h_or_i.end)
|
||
|
new_range = h_or_i.exclude_end? ? (index_begin...index_end) :
|
||
|
(index_begin..index_end)
|
||
|
fields.values_at(new_range)
|
||
|
else
|
||
|
[field(*Array(h_or_i))]
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
alias_method :values_at, :fields
|
||
|
|
||
|
#
|
||
|
# :call-seq:
|
||
|
# index( header )
|
||
|
# index( header, offset )
|
||
|
#
|
||
|
# This method will return the index of a field with the provided +header+.
|
||
|
# The +offset+ can be used to locate duplicate header names, as described in
|
||
|
# FasterCSV::Row.field().
|
||
|
#
|
||
|
def index(header, minimum_index = 0)
|
||
|
# find the pair
|
||
|
index = headers[minimum_index..-1].index(header)
|
||
|
# return the index at the right offset, if we found one
|
||
|
index.nil? ? nil : index + minimum_index
|
||
|
end
|
||
|
|
||
|
# Returns +true+ if +name+ is a header for this row, and +false+ otherwise.
|
||
|
def header?(name)
|
||
|
headers.include? name
|
||
|
end
|
||
|
alias_method :include?, :header?
|
||
|
|
||
|
#
|
||
|
# Returns +true+ if +data+ matches a field in this row, and +false+
|
||
|
# otherwise.
|
||
|
#
|
||
|
def field?(data)
|
||
|
fields.include? data
|
||
|
end
|
||
|
include Enumerable
|
||
|
|
||
|
#
|
||
|
# Yields each pair of the row as header and field tuples (much like
|
||
|
# iterating over a Hash).
|
||
|
#
|
||
|
# Support for Enumerable.
|
||
|
#
|
||
|
# This method returns the row for chaining.
|
||
|
#
|
||
|
def each(&block)
|
||
|
@row.each(&block)
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns +true+ if this row contains the same headers and fields in the
|
||
|
# same order as +other+.
|
||
|
#
|
||
|
def ==(other)
|
||
|
@row == other.row
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Collapses the row into a simple Hash. Be warning that this discards field
|
||
|
# order and clobbers duplicate fields.
|
||
|
#
|
||
|
def to_hash
|
||
|
# flatten just one level of the internal Array
|
||
|
Hash[*@row.inject(Array.new) { |ary, pair| ary.push(*pair) }]
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns the row as a CSV String. Headers are not used. Equivalent to:
|
||
|
#
|
||
|
# faster_csv_row.fields.to_csv( options )
|
||
|
#
|
||
|
def to_csv(options = Hash.new)
|
||
|
fields.to_csv(options)
|
||
|
end
|
||
|
alias_method :to_s, :to_csv
|
||
|
|
||
|
# A summary of fields, by header.
|
||
|
def inspect
|
||
|
str = "#<#{self.class}"
|
||
|
each do |header, field|
|
||
|
str << " #{header.is_a?(Symbol) ? header.to_s : header.inspect}:" <<
|
||
|
field.inspect
|
||
|
end
|
||
|
str << ">"
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# A FasterCSV::Table is a two-dimensional data structure for representing CSV
|
||
|
# documents. Tables allow you to work with the data by row or column,
|
||
|
# manipulate the data, and even convert the results back to CSV, if needed.
|
||
|
#
|
||
|
# All tables returned by FasterCSV will be constructed from this class, if
|
||
|
# header row processing is activated.
|
||
|
#
|
||
|
class Table
|
||
|
#
|
||
|
# Construct a new FasterCSV::Table from +array_of_rows+, which are expected
|
||
|
# to be FasterCSV::Row objects. All rows are assumed to have the same
|
||
|
# headers.
|
||
|
#
|
||
|
# A FasterCSV::Table object supports the following Array methods through
|
||
|
# delegation:
|
||
|
#
|
||
|
# * empty?()
|
||
|
# * length()
|
||
|
# * size()
|
||
|
#
|
||
|
def initialize(array_of_rows)
|
||
|
@table = array_of_rows
|
||
|
@mode = :col_or_row
|
||
|
end
|
||
|
|
||
|
# The current access mode for indexing and iteration.
|
||
|
attr_reader :mode
|
||
|
|
||
|
# Internal data format used to compare equality.
|
||
|
attr_reader :table
|
||
|
protected :table
|
||
|
### Array Delegation ###
|
||
|
extend Forwardable
|
||
|
def_delegators :@table, :empty?, :length, :size
|
||
|
|
||
|
#
|
||
|
# Returns a duplicate table object, in column mode. This is handy for
|
||
|
# chaining in a single call without changing the table mode, but be aware
|
||
|
# that this method can consume a fair amount of memory for bigger data sets.
|
||
|
#
|
||
|
# This method returns the duplicate table for chaining. Don't chain
|
||
|
# destructive methods (like []=()) this way though, since you are working
|
||
|
# with a duplicate.
|
||
|
#
|
||
|
def by_col
|
||
|
self.class.new(@table.dup).by_col!
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Switches the mode of this table to column mode. All calls to indexing and
|
||
|
# iteration methods will work with columns until the mode is changed again.
|
||
|
#
|
||
|
# This method returns the table and is safe to chain.
|
||
|
#
|
||
|
def by_col!
|
||
|
@mode = :col
|
||
|
|
||
|
self
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns a duplicate table object, in mixed mode. This is handy for
|
||
|
# chaining in a single call without changing the table mode, but be aware
|
||
|
# that this method can consume a fair amount of memory for bigger data sets.
|
||
|
#
|
||
|
# This method returns the duplicate table for chaining. Don't chain
|
||
|
# destructive methods (like []=()) this way though, since you are working
|
||
|
# with a duplicate.
|
||
|
#
|
||
|
def by_col_or_row
|
||
|
self.class.new(@table.dup).by_col_or_row!
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Switches the mode of this table to mixed mode. All calls to indexing and
|
||
|
# iteration methods will use the default intelligent indexing system until
|
||
|
# the mode is changed again. In mixed mode an index is assumed to be a row
|
||
|
# reference while anything else is assumed to be column access by headers.
|
||
|
#
|
||
|
# This method returns the table and is safe to chain.
|
||
|
#
|
||
|
def by_col_or_row!
|
||
|
@mode = :col_or_row
|
||
|
|
||
|
self
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns a duplicate table object, in row mode. This is handy for chaining
|
||
|
# in a single call without changing the table mode, but be aware that this
|
||
|
# method can consume a fair amount of memory for bigger data sets.
|
||
|
#
|
||
|
# This method returns the duplicate table for chaining. Don't chain
|
||
|
# destructive methods (like []=()) this way though, since you are working
|
||
|
# with a duplicate.
|
||
|
#
|
||
|
def by_row
|
||
|
self.class.new(@table.dup).by_row!
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Switches the mode of this table to row mode. All calls to indexing and
|
||
|
# iteration methods will work with rows until the mode is changed again.
|
||
|
#
|
||
|
# This method returns the table and is safe to chain.
|
||
|
#
|
||
|
def by_row!
|
||
|
@mode = :row
|
||
|
|
||
|
self
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns the headers for the first row of this table (assumed to match all
|
||
|
# other rows). An empty Array is returned for empty tables.
|
||
|
#
|
||
|
def headers
|
||
|
if @table.empty?
|
||
|
Array.new
|
||
|
else
|
||
|
@table.first.headers
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# In the default mixed mode, this method returns rows for index access and
|
||
|
# columns for header access. You can force the index association by first
|
||
|
# calling by_col!() or by_row!().
|
||
|
#
|
||
|
# Columns are returned as an Array of values. Altering that Array has no
|
||
|
# effect on the table.
|
||
|
#
|
||
|
def [](index_or_header)
|
||
|
if @mode == :row or # by index
|
||
|
(@mode == :col_or_row and index_or_header.is_a? Integer)
|
||
|
@table[index_or_header]
|
||
|
else # by header
|
||
|
@table.map { |row| row[index_or_header] }
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# In the default mixed mode, this method assigns rows for index access and
|
||
|
# columns for header access. You can force the index association by first
|
||
|
# calling by_col!() or by_row!().
|
||
|
#
|
||
|
# Rows may be set to an Array of values (which will inherit the table's
|
||
|
# headers()) or a FasterCSV::Row.
|
||
|
#
|
||
|
# Columns may be set to a single value, which is copied to each row of the
|
||
|
# column, or an Array of values. Arrays of values are assigned to rows top
|
||
|
# to bottom in row major order. Excess values are ignored and if the Array
|
||
|
# does not have a value for each row the extra rows will receive a +nil+.
|
||
|
#
|
||
|
# Assigning to an existing column or row clobbers the data. Assigning to
|
||
|
# new columns creates them at the right end of the table.
|
||
|
#
|
||
|
def []=(index_or_header, value)
|
||
|
if @mode == :row or # by index
|
||
|
(@mode == :col_or_row and index_or_header.is_a? Integer)
|
||
|
if value.is_a? Array
|
||
|
@table[index_or_header] = Row.new(headers, value)
|
||
|
else
|
||
|
@table[index_or_header] = value
|
||
|
end
|
||
|
else # set column
|
||
|
if value.is_a? Array # multiple values
|
||
|
@table.each_with_index do |row, i|
|
||
|
if row.header_row?
|
||
|
row[index_or_header] = index_or_header
|
||
|
else
|
||
|
row[index_or_header] = value[i]
|
||
|
end
|
||
|
end
|
||
|
else # repeated value
|
||
|
@table.each do |row|
|
||
|
if row.header_row?
|
||
|
row[index_or_header] = index_or_header
|
||
|
else
|
||
|
row[index_or_header] = value
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# The mixed mode default is to treat a list of indices as row access,
|
||
|
# returning the rows indicated. Anything else is considered columnar
|
||
|
# access. For columnar access, the return set has an Array for each row
|
||
|
# with the values indicated by the headers in each Array. You can force
|
||
|
# column or row mode using by_col!() or by_row!().
|
||
|
#
|
||
|
# You cannot mix column and row access.
|
||
|
#
|
||
|
def values_at(*indices_or_headers)
|
||
|
if @mode == :row or # by indices
|
||
|
( @mode == :col_or_row and indices_or_headers.all? do |index|
|
||
|
index.is_a?(Integer) or
|
||
|
( index.is_a?(Range) and
|
||
|
index.first.is_a?(Integer) and
|
||
|
index.last.is_a?(Integer) )
|
||
|
end )
|
||
|
@table.values_at(*indices_or_headers)
|
||
|
else # by headers
|
||
|
@table.map { |row| row.values_at(*indices_or_headers) }
|
||
|
end
|
||
|
end
|
||
|
#
|
||
|
# Adds a new row to the bottom end of this table. You can provide an Array,
|
||
|
# which will be converted to a FasterCSV::Row (inheriting the table's
|
||
|
# headers()), or a FasterCSV::Row.
|
||
|
#
|
||
|
# This method returns the table for chaining.
|
||
|
#
|
||
|
def <<(row_or_array)
|
||
|
if row_or_array.is_a? Array # append Array
|
||
|
@table << Row.new(headers, row_or_array)
|
||
|
else # append Row
|
||
|
@table << row_or_array
|
||
|
end
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# A shortcut for appending multiple rows. Equivalent to:
|
||
|
#
|
||
|
# rows.each { |row| self << row }
|
||
|
#
|
||
|
# This method returns the table for chaining.
|
||
|
#
|
||
|
def push(*rows)
|
||
|
rows.each { |row| self << row }
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
#
|
||
|
# Removes and returns the indicated column or row. In the default mixed
|
||
|
# mode indices refer to rows and everything else is assumed to be a column
|
||
|
# header. Use by_col!() or by_row!() to force the lookup.
|
||
|
#
|
||
|
def delete(index_or_header)
|
||
|
if @mode == :row or # by index
|
||
|
(@mode == :col_or_row and index_or_header.is_a? Integer)
|
||
|
@table.delete_at(index_or_header)
|
||
|
else # by header
|
||
|
@table.map { |row| row.delete(index_or_header).last }
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Removes any column or row for which the block returns +true+. In the
|
||
|
# default mixed mode or row mode, iteration is the standard row major
|
||
|
# walking of rows. In column mode, interation will +yield+ two element
|
||
|
# tuples containing the column name and an Array of values for that column.
|
||
|
#
|
||
|
# This method returns the table for chaining.
|
||
|
#
|
||
|
def delete_if(&block)
|
||
|
if @mode == :row or @mode == :col_or_row # by index
|
||
|
@table.delete_if(&block)
|
||
|
else # by header
|
||
|
to_delete = Array.new
|
||
|
headers.each_with_index do |header, i|
|
||
|
to_delete << header if block[[header, self[header]]]
|
||
|
end
|
||
|
to_delete.map { |header| delete(header) }
|
||
|
end
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
include Enumerable
|
||
|
|
||
|
#
|
||
|
# In the default mixed mode or row mode, iteration is the standard row major
|
||
|
# walking of rows. In column mode, interation will +yield+ two element
|
||
|
# tuples containing the column name and an Array of values for that column.
|
||
|
#
|
||
|
# This method returns the table for chaining.
|
||
|
#
|
||
|
def each(&block)
|
||
|
if @mode == :col
|
||
|
headers.each { |header| block[[header, self[header]]] }
|
||
|
else
|
||
|
@table.each(&block)
|
||
|
end
|
||
|
|
||
|
self # for chaining
|
||
|
end
|
||
|
|
||
|
# Returns +true+ if all rows of this table ==() +other+'s rows.
|
||
|
def ==(other)
|
||
|
@table == other.table
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns the table as an Array of Arrays. Headers will be the first row,
|
||
|
# then all of the field rows will follow.
|
||
|
#
|
||
|
def to_a
|
||
|
@table.inject([headers]) do |array, row|
|
||
|
if row.header_row?
|
||
|
array
|
||
|
else
|
||
|
array + [row.fields]
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# Returns the table as a complete CSV String. Headers will be listed first,
|
||
|
# then all of the field rows.
|
||
|
#
|
||
|
def to_csv(options = Hash.new)
|
||
|
@table.inject([headers.to_csv(options)]) do |rows, row|
|
||
|
if row.header_row?
|
||
|
rows
|
||
|
else
|
||
|
rows + [row.fields.to_csv(options)]
|
||
|
end
|
||
|
end.join
|
||
|
end
|
||
|
alias_method :to_s, :to_csv
|
||
|
|
||
|
def inspect
|
||
|
"#<#{self.class} mode:#{@mode} row_count:#{to_a.size}>"
|
||
|
end
|
||
|
end
|
||
|
# The error thrown when the parser encounters illegal CSV formatting.
|
||
|
class MalformedCSVError < RuntimeError; end
|
||
|
|
||
|
#
|
||
|
# A FieldInfo Struct contains details about a field's position in the data
|
||
|
# source it was read from. FasterCSV will pass this Struct to some blocks
|
||
|
# that make decisions based on field structure. See
|
||
|
# FasterCSV.convert_fields() for an example.
|
||
|
#
|
||
|
# <b><tt>index</tt></b>:: The zero-based index of the field in its row.
|
||
|
# <b><tt>line</tt></b>:: The line of the data source this row is from.
|
||
|
# <b><tt>header</tt></b>:: The header for the column, when available.
|
||
|
#
|
||
|
FieldInfo = Struct.new(:index, :line, :header)
|
||
|
|
||
|
# A Regexp used to find and convert some common Date formats.
|
||
|
DateMatcher = / \A(?: (\w+,?\s+)?\w+\s+\d{1,2},?\s+\d{2,4} |
|
||
|
\d{4}-\d{2}-\d{2} )\z /x
|
||
|
# A Regexp used to find and convert some common DateTime formats.
|
||
|
DateTimeMatcher =
|
||
|
/ \A(?: (\w+,?\s+)?\w+\s+\d{1,2}\s+\d{1,2}:\d{1,2}:\d{1,2},?\s+\d{2,4} |
|
||
|
\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2} )\z /x
|
||
|
#
|
||
|
# This Hash holds the built-in converters of FasterCSV that can be accessed by
|
||
|
# name. You can select Converters with FasterCSV.convert() or through the
|
||
|
# +options+ Hash passed to FasterCSV::new().
|
||
|
#
|
||
|
# <b><tt>:integer</tt></b>:: Converts any field Integer() accepts.
|
||
|
# <b><tt>:float</tt></b>:: Converts any field Float() accepts.
|
||
|
# <b><tt>:numeric</tt></b>:: A combination of <tt>:integer</tt>
|
||
|
# and <tt>:float</tt>.
|
||
|
# <b><tt>:date</tt></b>:: Converts any field Date::parse() accepts.
|
||
|
# <b><tt>:date_time</tt></b>:: Converts any field DateTime::parse() accepts.
|
||
|
# <b><tt>:all</tt></b>:: All built-in converters. A combination of
|
||
|
# <tt>:date_time</tt> and <tt>:numeric</tt>.
|
||
|
#
|
||
|
# This Hash is intetionally left unfrozen and users should feel free to add
|
||
|
# values to it that can be accessed by all FasterCSV objects.
|
||
|
#
|
||
|
# To add a combo field, the value should be an Array of names. Combo fields
|
||
|
# can be nested with other combo fields.
|
||
|
#
|
||
|
Converters = { :integer => lambda { |f| Integer(f) rescue f },
|
||
|
:float => lambda { |f| Float(f) rescue f },
|
||
|
:numeric => [:integer, :float],
|
||
|
:date => lambda { |f|
|
||
|
f =~ DateMatcher ? (Date.parse(f) rescue f) : f
|
||
|
},
|
||
|
:date_time => lambda { |f|
|
||
|
f =~ DateTimeMatcher ? (DateTime.parse(f) rescue f) : f
|
||
|
},
|
||
|
:all => [:date_time, :numeric] }
|
||
|
#
|
||
|
# This Hash holds the built-in header converters of FasterCSV that can be
|
||
|
# accessed by name. You can select HeaderConverters with
|
||
|
# FasterCSV.header_convert() or through the +options+ Hash passed to
|
||
|
# FasterCSV::new().
|
||
|
#
|
||
|
# <b><tt>:downcase</tt></b>:: Calls downcase() on the header String.
|
||
|
# <b><tt>:symbol</tt></b>:: The header String is downcased, spaces are
|
||
|
# replaced with underscores, non-word characters
|
||
|
# are dropped, and finally to_sym() is called.
|
||
|
#
|
||
|
# This Hash is intetionally left unfrozen and users should feel free to add
|
||
|
# values to it that can be accessed by all FasterCSV objects.
|
||
|
#
|
||
|
# To add a combo field, the value should be an Array of names. Combo fields
|
||
|
# can be nested with other combo fields.
|
||
|
#
|
||
|
HeaderConverters = {
|
||
|
:downcase => lambda { |h| h.downcase },
|
||
|
:symbol => lambda { |h|
|
||
|
h.downcase.tr(" ", "_").delete("^a-z0-9_").to_sym
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#
|
||
|
# The options used when no overrides are given by calling code. They are:
|
||
|
#
|
||
|
# <b><tt>:col_sep</tt></b>:: <tt>","</tt>
|
||
|
# <b><tt>:row_sep</tt></b>:: <tt>:auto</tt>
|
||
|
# <b><tt>:quote_char</tt></b>:: <tt>'"'</tt>
|
||
|
# <b><tt>:converters</tt></b>:: +nil+
|
||
|
# <b><tt>:unconverted_fields</tt></b>:: +nil+
|
||
|
# <b><tt>:headers</tt></b>:: +false+
|
||
|
# <b><tt>:return_headers</tt></b>:: +false+
|
||
|
# <b><tt>:header_converters</tt></b>:: +nil+
|
||
|
# <b><tt>:skip_blanks</tt></b>:: +false+
|
||
|
# <b><tt>:force_quotes</tt></b>:: +false+
|
||
|
#
|
||
|
DEFAULT_OPTIONS = { :col_sep => ",",
|
||
|
:row_sep => :auto,
|
||
|
:quote_char => '"',
|
||
|
:converters => nil,
|
||
|
:unconverted_fields => nil,
|
||
|
:headers => false,
|
||
|
:return_headers => false,
|
||
|
:header_converters => nil,
|
||
|
:skip_blanks => false,
|
||
|
:force_quotes => false }.freeze
|
||
|
|
||
|
#
|
||
|
# This method will build a drop-in replacement for many of the standard CSV
|
||
|
# methods. It allows you to write code like:
|
||
|
#
|
||
|
# begin
|
||
|
# require "faster_csv"
|
||
|
# FasterCSV.build_csv_interface
|
||
|
# rescue LoadError
|
||
|
# require "csv"
|
||
|
# end
|
||
|
# # ... use CSV here ...
|
||
|
#
|
||
|
# This is not a complete interface with completely identical behavior.
|
||
|
# However, it is intended to be close enough that you won't notice the
|
||
|
# difference in most cases. CSV methods supported are:
|
||
|
#
|
||
|
# * foreach()
|
||
|
# * generate_line()
|
||
|
# * open()
|
||
|
# * parse()
|
||
|
# * parse_line()
|
||
|
# * readlines()
|
||
|
#
|
||
|
# Be warned that this interface is slower than vanilla FasterCSV due to the
|
||
|
# extra layer of method calls. Depending on usage, this can slow it down to
|
||
|
# near CSV speeds.
|
||
|
#
|
||
|
def self.build_csv_interface
|
||
|
Object.const_set(:CSV, Class.new).class_eval do
|
||
|
def self.foreach(path, rs = :auto, &block) # :nodoc:
|
||
|
FasterCSV.foreach(path, :row_sep => rs, &block)
|
||
|
end
|
||
|
|
||
|
def self.generate_line(row, fs = ",", rs = "") # :nodoc:
|
||
|
FasterCSV.generate_line(row, :col_sep => fs, :row_sep => rs)
|
||
|
end
|
||
|
|
||
|
def self.open(path, mode, fs = ",", rs = :auto, &block) # :nodoc:
|
||
|
if block and mode.include? "r"
|
||
|
FasterCSV.open(path, mode, :col_sep => fs, :row_sep => rs) do |csv|
|
||
|
csv.each(&block)
|
||
|
end
|
||
|
else
|
||
|
FasterCSV.open(path, mode, :col_sep => fs, :row_sep => rs, &block)
|
||
|
end
|
||
|
end
|
||
|
|
||
|
def self.parse(str_or_readable, fs = ",", rs = :auto, &block) # :nodoc:
|
||
|
FasterCSV.parse(str_or_readable, :col_sep => fs, :row_sep => rs, &block)
|
||
|
end
|
||
|
|
||
|
def self.parse_line(src, fs = ",", rs = :auto) # :nodoc:
|
||
|
FasterCSV.parse_line(src, :col_sep => fs, :row_sep => rs)
|
||
|
end
|
||
|
|
||
|
def self.readlines(path, rs = :auto) # :nodoc:
|
||
|
FasterCSV.readlines(path, :row_sep => rs)
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# This method allows you to serialize an Array of Ruby objects to a String or
|
||
|
# File of CSV data. This is not as powerful as Marshal or YAML, but perhaps
|
||
|
# useful for spreadsheet and database interaction.
|
||
|
#
|
||
|
# Out of the box, this method is intended to work with simple data objects or
|
||
|
# Structs. It will serialize a list of instance variables and/or
|
||
|
# Struct.members().
|
||
|
#
|
||
|
# If you need need more complicated serialization, you can control the process
|
||
|
# by adding methods to the class to be serialized.
|
||
|
#
|
||
|
# A class method csv_meta() is responsible for returning the first row of the
|
||
|
# document (as an Array). This row is considered to be a Hash of the form
|
||
|
# key_1,value_1,key_2,value_2,... FasterCSV::load() expects to find a class
|
||
|
# key with a value of the stringified class name and FasterCSV::dump() will
|
||
|
# create this, if you do not define this method. This method is only called
|
||
|
# on the first object of the Array.
|
||
|
#
|
||
|
# The next method you can provide is an instance method called csv_headers().
|
||
|
# This method is expected to return the second line of the document (again as
|
||
|
# an Array), which is to be used to give each column a header. By default,
|
||
|
# FasterCSV::load() will set an instance variable if the field header starts
|
||
|
# with an @ character or call send() passing the header as the method name and
|
||
|
# the field value as an argument. This method is only called on the first
|
||
|
# object of the Array.
|
||
|
#
|
||
|
# Finally, you can provide an instance method called csv_dump(), which will
|
||
|
# be passed the headers. This should return an Array of fields that can be
|
||
|
# serialized for this object. This method is called once for every object in
|
||
|
# the Array.
|
||
|
#
|
||
|
# The +io+ parameter can be used to serialize to a File, and +options+ can be
|
||
|
# anything FasterCSV::new() accepts.
|
||
|
#
|
||
|
def self.dump(ary_of_objs, io = "", options = Hash.new)
|
||
|
obj_template = ary_of_objs.first
|
||
|
|
||
|
csv = FasterCSV.new(io, options)
|
||
|
|
||
|
# write meta information
|
||
|
begin
|
||
|
csv << obj_template.class.csv_meta
|
||
|
rescue NoMethodError
|
||
|
csv << [:class, obj_template.class]
|
||
|
end
|
||
|
# write headers
|
||
|
begin
|
||
|
headers = obj_template.csv_headers
|
||
|
rescue NoMethodError
|
||
|
headers = obj_template.instance_variables.sort
|
||
|
if obj_template.class.ancestors.find { |cls| cls.to_s =~ /\AStruct\b/ }
|
||
|
headers += obj_template.members.map { |mem| "#{mem}=" }.sort
|
||
|
end
|
||
|
end
|
||
|
csv << headers
|
||
|
|
||
|
# serialize each object
|
||
|
ary_of_objs.each do |obj|
|
||
|
begin
|
||
|
csv << obj.csv_dump(headers)
|
||
|
rescue NoMethodError
|
||
|
csv << headers.map do |var|
|
||
|
if var[0] == ?@
|
||
|
obj.instance_variable_get(var)
|
||
|
else
|
||
|
obj[var[0..-2]]
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
|
||
|
if io.is_a? String
|
||
|
csv.string
|
||
|
else
|
||
|
csv.close
|
||
|
end
|
||
|
end
|
||
|
|
||
|
#
|
||
|
# :call-seq:
|
||
|
# filter( options = Hash.new ) { |row| ... }
|
||
|
# filter( input, options = Hash.new ) { |row| ... }
|
||
|
# filter( input, output, options = Hash.new ) { |row| ... }
|
||
|
#
|
||
|
# This method is a convenience for building Unix-like filters for CSV data.
|
||
|
# Each row is yielded to the provided block which can alter it as needed.
|
||
|
# After the block returns, the row is appended to +output+ altered or not.
|
||
|
#
|
||
|
# The +input+ and +output+ arguments can be anything FasterCSV::new() accepts
|
||
|
# (generally String or IO objects). If not given, they default to
|
||
|
# <tt>ARGF</tt> and <tt>$stdout</tt>.
|
||
|
#
|
||
|
# The +options+ parameter is also filtered down to FasterCSV::new() after some
|
||
|
# clever key parsing. Any key beginning with <tt>:in_</tt> or
|
||
|
# <tt>:input_</tt> will have that leading identifier stripped and will only
|
||
|
# be used in the +options+ Hash for the +input+ object. Keys starting with
|
||
|
# <tt>:out_</tt> or <tt>:output_</tt> affect only +output+. All other keys
|
||
|
# are assigned to both objects.
|
||
|
#
|
||
|
# The <tt>:output_row_sep</tt> +option+ defaults to
|
||
|
# <tt>$INPUT_RECORD_SEPARATOR</tt> (<tt>$/</tt>).
|
||
|
#
|
||
|
def self.filter(*args)
|
||
|
# parse options for input, output, or both
|
||
|
in_options, out_options = Hash.new, {:row_sep => $INPUT_RECORD_SEPARATOR}
|
||
|
if args.last.is_a? Hash
|
||
|
args.pop.each do |key, value|
|
||
|
case key.to_s
|
||
|
when /\Ain(?:put)?_(.+)\Z/
|
||
|
in_options[$1.to_sym] = value
|
||
|
when /\Aout(?:put)?_(.+)\Z/
|
||
|
out_options[$1.to_sym] = value
|
||
|
else
|
||
|
in_options[key] = value
|
||