jro_apps/redmine Commit - r2893:27e3fa2bed6b

Use FasterCSV or ruby1.9 CSV instead of ruby1.8 builtin CSV....

Jean-Philippe Lang -

r2893:27e3fa2bed6b

parent child

Context file:

r2893:27e3fa2bed6b

Collapse all files

lib/faster_csv.rb created 644 +1984 0

This diff has been collapsed as it changes many lines, (1984 lines changed) Show them Hide them
	@@ -0,0 +1,1984
		1	#!/usr/local/bin/ruby -w
		2
		3	# = faster_csv.rb -- Faster CSV Reading and Writing
		4	#
		5	# Created by James Edward Gray II on 2005-10-31.
		6	# Copyright 2005 Gray Productions. All rights reserved.
		7	#
		8	# See FasterCSV for documentation.
		9
		10	if RUBY_VERSION >= "1.9"
		11	abort <<-VERSION_WARNING.gsub(/^\s+/, "")
		12	Please switch to Ruby 1.9's standard CSV library. It's FasterCSV plus
		13	support for Ruby 1.9's m17n encoding engine.
		14	VERSION_WARNING
		15	end
		16
		17	require "forwardable"
		18	require "English"
		19	require "enumerator"
		20	require "date"
		21	require "stringio"
		22
		23	#
		24	# This class provides a complete interface to CSV files and data. It offers
		25	# tools to enable you to read and write to and from Strings or IO objects, as
		26	# needed.
		27	#
		28	# == Reading
		29	#
		30	# === From a File
		31	#
		32	# ==== A Line at a Time
		33	#
		34	# FasterCSV.foreach("path/to/file.csv") do \|row\|
		35	# # use row here...
		36	# end
		37	#
		38	# ==== All at Once
		39	#
		40	# arr_of_arrs = FasterCSV.read("path/to/file.csv")
		41	#
		42	# === From a String
		43	#
		44	# ==== A Line at a Time
		45	#
		46	# FasterCSV.parse("CSV,data,String") do \|row\|
		47	# # use row here...
		48	# end
		49	#
		50	# ==== All at Once
		51	#
		52	# arr_of_arrs = FasterCSV.parse("CSV,data,String")
		53	#
		54	# == Writing
		55	#
		56	# === To a File
		57	#
		58	# FasterCSV.open("path/to/file.csv", "w") do \|csv\|
		59	# csv << ["row", "of", "CSV", "data"]
		60	# csv << ["another", "row"]
		61	# # ...
		62	# end
		63	#
		64	# === To a String
		65	#
		66	# csv_string = FasterCSV.generate do \|csv\|
		67	# csv << ["row", "of", "CSV", "data"]
		68	# csv << ["another", "row"]
		69	# # ...
		70	# end
		71	#
		72	# == Convert a Single Line
		73	#
		74	# csv_string = ["CSV", "data"].to_csv # to CSV
		75	# csv_array = "CSV,String".parse_csv # from CSV
		76	#
		77	# == Shortcut Interface
		78	#
		79	# FCSV { \|csv_out\| csv_out << %w{my data here} } # to $stdout
		80	# FCSV(csv = "") { \|csv_str\| csv_str << %w{my data here} } # to a String
		81	# FCSV($stderr) { \|csv_err\| csv_err << %w{my data here} } # to $stderr
		82	#
		83	class FasterCSV
		84	# The version of the installed library.
		85	VERSION = "1.5.0".freeze
		86
		87	#
		88	# A FasterCSV::Row is part Array and part Hash. It retains an order for the
		89	# fields and allows duplicates just as an Array would, but also allows you to
		90	# access fields by name just as you could if they were in a Hash.
		91	#
		92	# All rows returned by FasterCSV will be constructed from this class, if
		93	# header row processing is activated.
		94	#
		95	class Row
		96	#
		97	# Construct a new FasterCSV::Row from +headers+ and +fields+, which are
		98	# expected to be Arrays. If one Array is shorter than the other, it will be
		99	# padded with +nil+ objects.
		100	#
		101	# The optional +header_row+ parameter can be set to +true+ to indicate, via
		102	# FasterCSV::Row.header_row?() and FasterCSV::Row.field_row?(), that this is
		103	# a header row. Otherwise, the row is assumes to be a field row.
		104	#
		105	# A FasterCSV::Row object supports the following Array methods through
		106	# delegation:
		107	#
		108	# * empty?()
		109	# * length()
		110	# * size()
		111	#
		112	def initialize(headers, fields, header_row = false)
		113	@header_row = header_row
		114
		115	# handle extra headers or fields
		116	@row = if headers.size > fields.size
		117	headers.zip(fields)
		118	else
		119	fields.zip(headers).map { \|pair\| pair.reverse }
		120	end
		121	end
		122
		123	# Internal data format used to compare equality.
		124	attr_reader :row
		125	protected :row
		126
		127	### Array Delegation ###
		128
		129	extend Forwardable
		130	def_delegators :@row, :empty?, :length, :size
		131
		132	# Returns +true+ if this is a header row.
		133	def header_row?
		134	@header_row
		135	end
		136
		137	# Returns +true+ if this is a field row.
		138	def field_row?
		139	not header_row?
		140	end
		141
		142	# Returns the headers of this row.
		143	def headers
		144	@row.map { \|pair\| pair.first }
		145	end
		146
		147	#
		148	# :call-seq:
		149	# field( header )
		150	# field( header, offset )
		151	# field( index )
		152	#
		153	# This method will fetch the field value by +header+ or +index+. If a field
		154	# is not found, +nil+ is returned.
		155	#
		156	# When provided, +offset+ ensures that a header match occurrs on or later
		157	# than the +offset+ index. You can use this to find duplicate headers,
		158	# without resorting to hard-coding exact indices.
		159	#
		160	def field(header_or_index, minimum_index = 0)
		161	# locate the pair
		162	finder = header_or_index.is_a?(Integer) ? :[] : :assoc
		163	pair = @row[minimum_index..-1].send(finder, header_or_index)
		164
		165	# return the field if we have a pair
		166	pair.nil? ? nil : pair.last
		167	end
		168	alias_method :[], :field
		169
		170	#
		171	# :call-seq:
		172	# []=( header, value )
		173	# []=( header, offset, value )
		174	# []=( index, value )
		175	#
		176	# Looks up the field by the semantics described in FasterCSV::Row.field()
		177	# and assigns the +value+.
		178	#
		179	# Assigning past the end of the row with an index will set all pairs between
		180	# to <tt>[nil, nil]</tt>. Assigning to an unused header appends the new
		181	# pair.
		182	#
		183	def []=(*args)
		184	value = args.pop
		185
		186	if args.first.is_a? Integer
		187	if @row[args.first].nil? # extending past the end with index
		188	@row[args.first] = [nil, value]
		189	@row.map! { \|pair\| pair.nil? ? [nil, nil] : pair }
		190	else # normal index assignment
		191	@row[args.first][1] = value
		192	end
		193	else
		194	index = index(*args)
		195	if index.nil? # appending a field
		196	self << [args.first, value]
		197	else # normal header assignment
		198	@row[index][1] = value
		199	end
		200	end
		201	end
		202
		203	#
		204	# :call-seq:
		205	# <<( field )
		206	# <<( header_and_field_array )
		207	# <<( header_and_field_hash )
		208	#
		209	# If a two-element Array is provided, it is assumed to be a header and field
		210	# and the pair is appended. A Hash works the same way with the key being
		211	# the header and the value being the field. Anything else is assumed to be
		212	# a lone field which is appended with a +nil+ header.
		213	#
		214	# This method returns the row for chaining.
		215	#
		216	def <<(arg)
		217	if arg.is_a?(Array) and arg.size == 2 # appending a header and name
		218	@row << arg
		219	elsif arg.is_a?(Hash) # append header and name pairs
		220	arg.each { \|pair\| @row << pair }
		221	else # append field value
		222	@row << [nil, arg]
		223	end
		224
		225	self # for chaining
		226	end
		227
		228	#
		229	# A shortcut for appending multiple fields. Equivalent to:
		230	#
		231	# args.each { \|arg\| faster_csv_row << arg }
		232	#
		233	# This method returns the row for chaining.
		234	#
		235	def push(*args)
		236	args.each { \|arg\| self << arg }
		237
		238	self # for chaining
		239	end
		240
		241	#
		242	# :call-seq:
		243	# delete( header )
		244	# delete( header, offset )
		245	# delete( index )
		246	#
		247	# Used to remove a pair from the row by +header+ or +index+. The pair is
		248	# located as described in FasterCSV::Row.field(). The deleted pair is
		249	# returned, or +nil+ if a pair could not be found.
		250	#
		251	def delete(header_or_index, minimum_index = 0)
		252	if header_or_index.is_a? Integer # by index
		253	@row.delete_at(header_or_index)
		254	else # by header
		255	@row.delete_at(index(header_or_index, minimum_index))
		256	end
		257	end
		258
		259	#
		260	# The provided +block+ is passed a header and field for each pair in the row
		261	# and expected to return +true+ or +false+, depending on whether the pair
		262	# should be deleted.
		263	#
		264	# This method returns the row for chaining.
		265	#
		266	def delete_if(&block)
		267	@row.delete_if(&block)
		268
		269	self # for chaining
		270	end
		271
		272	#
		273	# This method accepts any number of arguments which can be headers, indices,
		274	# Ranges of either, or two-element Arrays containing a header and offset.
		275	# Each argument will be replaced with a field lookup as described in
		276	# FasterCSV::Row.field().
		277	#
		278	# If called with no arguments, all fields are returned.
		279	#
		280	def fields(*headers_and_or_indices)
		281	if headers_and_or_indices.empty? # return all fields--no arguments
		282	@row.map { \|pair\| pair.last }
		283	else # or work like values_at()
		284	headers_and_or_indices.inject(Array.new) do \|all, h_or_i\|
		285	all + if h_or_i.is_a? Range
		286	index_begin = h_or_i.begin.is_a?(Integer) ? h_or_i.begin :
		287	index(h_or_i.begin)
		288	index_end = h_or_i.end.is_a?(Integer) ? h_or_i.end :
		289	index(h_or_i.end)
		290	new_range = h_or_i.exclude_end? ? (index_begin...index_end) :
		291	(index_begin..index_end)
		292	fields.values_at(new_range)
		293	else
		294	[field(*Array(h_or_i))]
		295	end
		296	end
		297	end
		298	end
		299	alias_method :values_at, :fields
		300
		301	#
		302	# :call-seq:
		303	# index( header )
		304	# index( header, offset )
		305	#
		306	# This method will return the index of a field with the provided +header+.
		307	# The +offset+ can be used to locate duplicate header names, as described in
		308	# FasterCSV::Row.field().
		309	#
		310	def index(header, minimum_index = 0)
		311	# find the pair
		312	index = headers[minimum_index..-1].index(header)
		313	# return the index at the right offset, if we found one
		314	index.nil? ? nil : index + minimum_index
		315	end
		316
		317	# Returns +true+ if +name+ is a header for this row, and +false+ otherwise.
		318	def header?(name)
		319	headers.include? name
		320	end
		321	alias_method :include?, :header?
		322
		323	#
		324	# Returns +true+ if +data+ matches a field in this row, and +false+
		325	# otherwise.
		326	#
		327	def field?(data)
		328	fields.include? data
		329	end
		330
		331	include Enumerable
		332
		333	#
		334	# Yields each pair of the row as header and field tuples (much like
		335	# iterating over a Hash).
		336	#
		337	# Support for Enumerable.
		338	#
		339	# This method returns the row for chaining.
		340	#
		341	def each(&block)
		342	@row.each(&block)
		343
		344	self # for chaining
		345	end
		346
		347	#
		348	# Returns +true+ if this row contains the same headers and fields in the
		349	# same order as +other+.
		350	#
		351	def ==(other)
		352	@row == other.row
		353	end
		354
		355	#
		356	# Collapses the row into a simple Hash. Be warning that this discards field
		357	# order and clobbers duplicate fields.
		358	#
		359	def to_hash
		360	# flatten just one level of the internal Array
		361	Hash[@row.inject(Array.new) { \|ary, pair\| ary.push(pair) }]
		362	end
		363
		364	#
		365	# Returns the row as a CSV String. Headers are not used. Equivalent to:
		366	#
		367	# faster_csv_row.fields.to_csv( options )
		368	#
		369	def to_csv(options = Hash.new)
		370	fields.to_csv(options)
		371	end
		372	alias_method :to_s, :to_csv
		373
		374	# A summary of fields, by header.
		375	def inspect
		376	str = "#<#{self.class}"
		377	each do \|header, field\|
		378	str << " #{header.is_a?(Symbol) ? header.to_s : header.inspect}:" <<
		379	field.inspect
		380	end
		381	str << ">"
		382	end
		383	end
		384
		385	#
		386	# A FasterCSV::Table is a two-dimensional data structure for representing CSV
		387	# documents. Tables allow you to work with the data by row or column,
		388	# manipulate the data, and even convert the results back to CSV, if needed.
		389	#
		390	# All tables returned by FasterCSV will be constructed from this class, if
		391	# header row processing is activated.
		392	#
		393	class Table
		394	#
		395	# Construct a new FasterCSV::Table from +array_of_rows+, which are expected
		396	# to be FasterCSV::Row objects. All rows are assumed to have the same
		397	# headers.
		398	#
		399	# A FasterCSV::Table object supports the following Array methods through
		400	# delegation:
		401	#
		402	# * empty?()
		403	# * length()
		404	# * size()
		405	#
		406	def initialize(array_of_rows)
		407	@table = array_of_rows
		408	@mode = :col_or_row
		409	end
		410
		411	# The current access mode for indexing and iteration.
		412	attr_reader :mode
		413
		414	# Internal data format used to compare equality.
		415	attr_reader :table
		416	protected :table
		417
		418	### Array Delegation ###
		419
		420	extend Forwardable
		421	def_delegators :@table, :empty?, :length, :size
		422
		423	#
		424	# Returns a duplicate table object, in column mode. This is handy for
		425	# chaining in a single call without changing the table mode, but be aware
		426	# that this method can consume a fair amount of memory for bigger data sets.
		427	#
		428	# This method returns the duplicate table for chaining. Don't chain
		429	# destructive methods (like []=()) this way though, since you are working
		430	# with a duplicate.
		431	#
		432	def by_col
		433	self.class.new(@table.dup).by_col!
		434	end
		435
		436	#
		437	# Switches the mode of this table to column mode. All calls to indexing and
		438	# iteration methods will work with columns until the mode is changed again.
		439	#
		440	# This method returns the table and is safe to chain.
		441	#
		442	def by_col!
		443	@mode = :col
		444
		445	self
		446	end
		447
		448	#
		449	# Returns a duplicate table object, in mixed mode. This is handy for
		450	# chaining in a single call without changing the table mode, but be aware
		451	# that this method can consume a fair amount of memory for bigger data sets.
		452	#
		453	# This method returns the duplicate table for chaining. Don't chain
		454	# destructive methods (like []=()) this way though, since you are working
		455	# with a duplicate.
		456	#
		457	def by_col_or_row
		458	self.class.new(@table.dup).by_col_or_row!
		459	end
		460
		461	#
		462	# Switches the mode of this table to mixed mode. All calls to indexing and
		463	# iteration methods will use the default intelligent indexing system until
		464	# the mode is changed again. In mixed mode an index is assumed to be a row
		465	# reference while anything else is assumed to be column access by headers.
		466	#
		467	# This method returns the table and is safe to chain.
		468	#
		469	def by_col_or_row!
		470	@mode = :col_or_row
		471
		472	self
		473	end
		474
		475	#
		476	# Returns a duplicate table object, in row mode. This is handy for chaining
		477	# in a single call without changing the table mode, but be aware that this
		478	# method can consume a fair amount of memory for bigger data sets.
		479	#
		480	# This method returns the duplicate table for chaining. Don't chain
		481	# destructive methods (like []=()) this way though, since you are working
		482	# with a duplicate.
		483	#
		484	def by_row
		485	self.class.new(@table.dup).by_row!
		486	end
		487
		488	#
		489	# Switches the mode of this table to row mode. All calls to indexing and
		490	# iteration methods will work with rows until the mode is changed again.
		491	#
		492	# This method returns the table and is safe to chain.
		493	#
		494	def by_row!
		495	@mode = :row
		496
		497	self
		498	end
		499
		500	#
		501	# Returns the headers for the first row of this table (assumed to match all
		502	# other rows). An empty Array is returned for empty tables.
		503	#
		504	def headers
		505	if @table.empty?
		506	Array.new
		507	else
		508	@table.first.headers
		509	end
		510	end
		511
		512	#
		513	# In the default mixed mode, this method returns rows for index access and
		514	# columns for header access. You can force the index association by first
		515	# calling by_col!() or by_row!().
		516	#
		517	# Columns are returned as an Array of values. Altering that Array has no
		518	# effect on the table.
		519	#
		520	def [](index_or_header)
		521	if @mode == :row or # by index
		522	(@mode == :col_or_row and index_or_header.is_a? Integer)
		523	@table[index_or_header]
		524	else # by header
		525	@table.map { \|row\| row[index_or_header] }
		526	end
		527	end
		528
		529	#
		530	# In the default mixed mode, this method assigns rows for index access and
		531	# columns for header access. You can force the index association by first
		532	# calling by_col!() or by_row!().
		533	#
		534	# Rows may be set to an Array of values (which will inherit the table's
		535	# headers()) or a FasterCSV::Row.
		536	#
		537	# Columns may be set to a single value, which is copied to each row of the
		538	# column, or an Array of values. Arrays of values are assigned to rows top
		539	# to bottom in row major order. Excess values are ignored and if the Array
		540	# does not have a value for each row the extra rows will receive a +nil+.
		541	#
		542	# Assigning to an existing column or row clobbers the data. Assigning to
		543	# new columns creates them at the right end of the table.
		544	#
		545	def []=(index_or_header, value)
		546	if @mode == :row or # by index
		547	(@mode == :col_or_row and index_or_header.is_a? Integer)
		548	if value.is_a? Array
		549	@table[index_or_header] = Row.new(headers, value)
		550	else
		551	@table[index_or_header] = value
		552	end
		553	else # set column
		554	if value.is_a? Array # multiple values
		555	@table.each_with_index do \|row, i\|
		556	if row.header_row?
		557	row[index_or_header] = index_or_header
		558	else
		559	row[index_or_header] = value[i]
		560	end
		561	end
		562	else # repeated value
		563	@table.each do \|row\|
		564	if row.header_row?
		565	row[index_or_header] = index_or_header
		566	else
		567	row[index_or_header] = value
		568	end
		569	end
		570	end
		571	end
		572	end
		573
		574	#
		575	# The mixed mode default is to treat a list of indices as row access,
		576	# returning the rows indicated. Anything else is considered columnar
		577	# access. For columnar access, the return set has an Array for each row
		578	# with the values indicated by the headers in each Array. You can force
		579	# column or row mode using by_col!() or by_row!().
		580	#
		581	# You cannot mix column and row access.
		582	#
		583	def values_at(*indices_or_headers)
		584	if @mode == :row or # by indices
		585	( @mode == :col_or_row and indices_or_headers.all? do \|index\|
		586	index.is_a?(Integer) or
		587	( index.is_a?(Range) and
		588	index.first.is_a?(Integer) and
		589	index.last.is_a?(Integer) )
		590	end )
		591	@table.values_at(*indices_or_headers)
		592	else # by headers
		593	@table.map { \|row\| row.values_at(*indices_or_headers) }
		594	end
		595	end
		596
		597	#
		598	# Adds a new row to the bottom end of this table. You can provide an Array,
		599	# which will be converted to a FasterCSV::Row (inheriting the table's
		600	# headers()), or a FasterCSV::Row.
		601	#
		602	# This method returns the table for chaining.
		603	#
		604	def <<(row_or_array)
		605	if row_or_array.is_a? Array # append Array
		606	@table << Row.new(headers, row_or_array)
		607	else # append Row
		608	@table << row_or_array
		609	end
		610
		611	self # for chaining
		612	end
		613
		614	#
		615	# A shortcut for appending multiple rows. Equivalent to:
		616	#
		617	# rows.each { \|row\| self << row }
		618	#
		619	# This method returns the table for chaining.
		620	#
		621	def push(*rows)
		622	rows.each { \|row\| self << row }
		623
		624	self # for chaining
		625	end
		626
		627	#
		628	# Removes and returns the indicated column or row. In the default mixed
		629	# mode indices refer to rows and everything else is assumed to be a column
		630	# header. Use by_col!() or by_row!() to force the lookup.
		631	#
		632	def delete(index_or_header)
		633	if @mode == :row or # by index
		634	(@mode == :col_or_row and index_or_header.is_a? Integer)
		635	@table.delete_at(index_or_header)
		636	else # by header
		637	@table.map { \|row\| row.delete(index_or_header).last }
		638	end
		639	end
		640
		641	#
		642	# Removes any column or row for which the block returns +true+. In the
		643	# default mixed mode or row mode, iteration is the standard row major
		644	# walking of rows. In column mode, interation will +yield+ two element
		645	# tuples containing the column name and an Array of values for that column.
		646	#
		647	# This method returns the table for chaining.
		648	#
		649	def delete_if(&block)
		650	if @mode == :row or @mode == :col_or_row # by index
		651	@table.delete_if(&block)
		652	else # by header
		653	to_delete = Array.new
		654	headers.each_with_index do \|header, i\|
		655	to_delete << header if block[[header, self[header]]]
		656	end
		657	to_delete.map { \|header\| delete(header) }
		658	end
		659
		660	self # for chaining
		661	end
		662
		663	include Enumerable
		664
		665	#
		666	# In the default mixed mode or row mode, iteration is the standard row major
		667	# walking of rows. In column mode, interation will +yield+ two element
		668	# tuples containing the column name and an Array of values for that column.
		669	#
		670	# This method returns the table for chaining.
		671	#
		672	def each(&block)
		673	if @mode == :col
		674	headers.each { \|header\| block[[header, self[header]]] }
		675	else
		676	@table.each(&block)
		677	end
		678
		679	self # for chaining
		680	end
		681
		682	# Returns +true+ if all rows of this table ==() +other+'s rows.
		683	def ==(other)
		684	@table == other.table
		685	end
		686
		687	#
		688	# Returns the table as an Array of Arrays. Headers will be the first row,
		689	# then all of the field rows will follow.
		690	#
		691	def to_a
		692	@table.inject([headers]) do \|array, row\|
		693	if row.header_row?
		694	array
		695	else
		696	array + [row.fields]
		697	end
		698	end
		699	end
		700
		701	#
		702	# Returns the table as a complete CSV String. Headers will be listed first,
		703	# then all of the field rows.
		704	#
		705	def to_csv(options = Hash.new)
		706	@table.inject([headers.to_csv(options)]) do \|rows, row\|
		707	if row.header_row?
		708	rows
		709	else
		710	rows + [row.fields.to_csv(options)]
		711	end
		712	end.join
		713	end
		714	alias_method :to_s, :to_csv
		715
		716	def inspect
		717	"#<#{self.class} mode:#{@mode} row_count:#{to_a.size}>"
		718	end
		719	end
		720
		721	# The error thrown when the parser encounters illegal CSV formatting.
		722	class MalformedCSVError < RuntimeError; end
		723
		724	#
		725	# A FieldInfo Struct contains details about a field's position in the data
		726	# source it was read from. FasterCSV will pass this Struct to some blocks
		727	# that make decisions based on field structure. See
		728	# FasterCSV.convert_fields() for an example.
		729	#
		730	# <b><tt>index</tt></b>:: The zero-based index of the field in its row.
		731	# <b><tt>line</tt></b>:: The line of the data source this row is from.
		732	# <b><tt>header</tt></b>:: The header for the column, when available.
		733	#
		734	FieldInfo = Struct.new(:index, :line, :header)
		735
		736	# A Regexp used to find and convert some common Date formats.
		737	DateMatcher = / \A(?: (\w+,?\s+)?\w+\s+\d{1,2},?\s+\d{2,4} \|
		738	\d{4}-\d{2}-\d{2} )\z /x
		739	# A Regexp used to find and convert some common DateTime formats.
		740	DateTimeMatcher =
		741	/ \A(?: (\w+,?\s+)?\w+\s+\d{1,2}\s+\d{1,2}:\d{1,2}:\d{1,2},?\s+\d{2,4} \|
		742	\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2} )\z /x
		743	#
		744	# This Hash holds the built-in converters of FasterCSV that can be accessed by
		745	# name. You can select Converters with FasterCSV.convert() or through the
		746	# +options+ Hash passed to FasterCSV::new().
		747	#
		748	# <b><tt>:integer</tt></b>:: Converts any field Integer() accepts.
		749	# <b><tt>:float</tt></b>:: Converts any field Float() accepts.
		750	# <b><tt>:numeric</tt></b>:: A combination of <tt>:integer</tt>
		751	# and <tt>:float</tt>.
		752	# <b><tt>:date</tt></b>:: Converts any field Date::parse() accepts.
		753	# <b><tt>:date_time</tt></b>:: Converts any field DateTime::parse() accepts.
		754	# <b><tt>:all</tt></b>:: All built-in converters. A combination of
		755	# <tt>:date_time</tt> and <tt>:numeric</tt>.
		756	#
		757	# This Hash is intetionally left unfrozen and users should feel free to add
		758	# values to it that can be accessed by all FasterCSV objects.
		759	#
		760	# To add a combo field, the value should be an Array of names. Combo fields
		761	# can be nested with other combo fields.
		762	#
		763	Converters = { :integer => lambda { \|f\| Integer(f) rescue f },
		764	:float => lambda { \|f\| Float(f) rescue f },
		765	:numeric => [:integer, :float],
		766	:date => lambda { \|f\|
		767	f =~ DateMatcher ? (Date.parse(f) rescue f) : f
		768	},
		769	:date_time => lambda { \|f\|
		770	f =~ DateTimeMatcher ? (DateTime.parse(f) rescue f) : f
		771	},
		772	:all => [:date_time, :numeric] }
		773
		774	#
		775	# This Hash holds the built-in header converters of FasterCSV that can be
		776	# accessed by name. You can select HeaderConverters with
		777	# FasterCSV.header_convert() or through the +options+ Hash passed to
		778	# FasterCSV::new().
		779	#
		780	# <b><tt>:downcase</tt></b>:: Calls downcase() on the header String.
		781	# <b><tt>:symbol</tt></b>:: The header String is downcased, spaces are
		782	# replaced with underscores, non-word characters
		783	# are dropped, and finally to_sym() is called.
		784	#
		785	# This Hash is intetionally left unfrozen and users should feel free to add
		786	# values to it that can be accessed by all FasterCSV objects.
		787	#
		788	# To add a combo field, the value should be an Array of names. Combo fields
		789	# can be nested with other combo fields.
		790	#
		791	HeaderConverters = {
		792	:downcase => lambda { \|h\| h.downcase },
		793	:symbol => lambda { \|h\|
		794	h.downcase.tr(" ", "_").delete("^a-z0-9_").to_sym
		795	}
		796	}
		797
		798	#
		799	# The options used when no overrides are given by calling code. They are:
		800	#
		801	# <b><tt>:col_sep</tt></b>:: <tt>","</tt>
		802	# <b><tt>:row_sep</tt></b>:: <tt>:auto</tt>
		803	# <b><tt>:quote_char</tt></b>:: <tt>'"'</tt>
		804	# <b><tt>:converters</tt></b>:: +nil+
		805	# <b><tt>:unconverted_fields</tt></b>:: +nil+
		806	# <b><tt>:headers</tt></b>:: +false+
		807	# <b><tt>:return_headers</tt></b>:: +false+
		808	# <b><tt>:header_converters</tt></b>:: +nil+
		809	# <b><tt>:skip_blanks</tt></b>:: +false+
		810	# <b><tt>:force_quotes</tt></b>:: +false+
		811	#
		812	DEFAULT_OPTIONS = { :col_sep => ",",
		813	:row_sep => :auto,
		814	:quote_char => '"',
		815	:converters => nil,
		816	:unconverted_fields => nil,
		817	:headers => false,
		818	:return_headers => false,
		819	:header_converters => nil,
		820	:skip_blanks => false,
		821	:force_quotes => false }.freeze
		822
		823	#
		824	# This method will build a drop-in replacement for many of the standard CSV
		825	# methods. It allows you to write code like:
		826	#
		827	# begin
		828	# require "faster_csv"
		829	# FasterCSV.build_csv_interface
		830	# rescue LoadError
		831	# require "csv"
		832	# end
		833	# # ... use CSV here ...
		834	#
		835	# This is not a complete interface with completely identical behavior.
		836	# However, it is intended to be close enough that you won't notice the
		837	# difference in most cases. CSV methods supported are:
		838	#
		839	# * foreach()
		840	# * generate_line()
		841	# * open()
		842	# * parse()
		843	# * parse_line()
		844	# * readlines()
		845	#
		846	# Be warned that this interface is slower than vanilla FasterCSV due to the
		847	# extra layer of method calls. Depending on usage, this can slow it down to
		848	# near CSV speeds.
		849	#
		850	def self.build_csv_interface
		851	Object.const_set(:CSV, Class.new).class_eval do
		852	def self.foreach(path, rs = :auto, &block) # :nodoc:
		853	FasterCSV.foreach(path, :row_sep => rs, &block)
		854	end
		855
		856	def self.generate_line(row, fs = ",", rs = "") # :nodoc:
		857	FasterCSV.generate_line(row, :col_sep => fs, :row_sep => rs)
		858	end
		859
		860	def self.open(path, mode, fs = ",", rs = :auto, &block) # :nodoc:
		861	if block and mode.include? "r"
		862	FasterCSV.open(path, mode, :col_sep => fs, :row_sep => rs) do \|csv\|
		863	csv.each(&block)
		864	end
		865	else
		866	FasterCSV.open(path, mode, :col_sep => fs, :row_sep => rs, &block)
		867	end
		868	end
		869
		870	def self.parse(str_or_readable, fs = ",", rs = :auto, &block) # :nodoc:
		871	FasterCSV.parse(str_or_readable, :col_sep => fs, :row_sep => rs, &block)
		872	end
		873
		874	def self.parse_line(src, fs = ",", rs = :auto) # :nodoc:
		875	FasterCSV.parse_line(src, :col_sep => fs, :row_sep => rs)
		876	end
		877
		878	def self.readlines(path, rs = :auto) # :nodoc:
		879	FasterCSV.readlines(path, :row_sep => rs)
		880	end
		881	end
		882	end
		883
		884	#
		885	# This method allows you to serialize an Array of Ruby objects to a String or
		886	# File of CSV data. This is not as powerful as Marshal or YAML, but perhaps
		887	# useful for spreadsheet and database interaction.
		888	#
		889	# Out of the box, this method is intended to work with simple data objects or
		890	# Structs. It will serialize a list of instance variables and/or
		891	# Struct.members().
		892	#
		893	# If you need need more complicated serialization, you can control the process
		894	# by adding methods to the class to be serialized.
		895	#
		896	# A class method csv_meta() is responsible for returning the first row of the
		897	# document (as an Array). This row is considered to be a Hash of the form
		898	# key_1,value_1,key_2,value_2,... FasterCSV::load() expects to find a class
		899	# key with a value of the stringified class name and FasterCSV::dump() will
		900	# create this, if you do not define this method. This method is only called
		901	# on the first object of the Array.
		902	#
		903	# The next method you can provide is an instance method called csv_headers().
		904	# This method is expected to return the second line of the document (again as
		905	# an Array), which is to be used to give each column a header. By default,
		906	# FasterCSV::load() will set an instance variable if the field header starts
		907	# with an @ character or call send() passing the header as the method name and
		908	# the field value as an argument. This method is only called on the first
		909	# object of the Array.
		910	#
		911	# Finally, you can provide an instance method called csv_dump(), which will
		912	# be passed the headers. This should return an Array of fields that can be
		913	# serialized for this object. This method is called once for every object in
		914	# the Array.
		915	#
		916	# The +io+ parameter can be used to serialize to a File, and +options+ can be
		917	# anything FasterCSV::new() accepts.
		918	#
		919	def self.dump(ary_of_objs, io = "", options = Hash.new)
		920	obj_template = ary_of_objs.first
		921
		922	csv = FasterCSV.new(io, options)
		923
		924	# write meta information
		925	begin
		926	csv << obj_template.class.csv_meta
		927	rescue NoMethodError
		928	csv << [:class, obj_template.class]
		929	end
		930
		931	# write headers
		932	begin
		933	headers = obj_template.csv_headers
		934	rescue NoMethodError
		935	headers = obj_template.instance_variables.sort
		936	if obj_template.class.ancestors.find { \|cls\| cls.to_s =~ /\AStruct\b/ }
		937	headers += obj_template.members.map { \|mem\| "#{mem}=" }.sort
		938	end
		939	end
		940	csv << headers
		941
		942	# serialize each object
		943	ary_of_objs.each do \|obj\|
		944	begin
		945	csv << obj.csv_dump(headers)
		946	rescue NoMethodError
		947	csv << headers.map do \|var\|
		948	if var[0] == ?@
		949	obj.instance_variable_get(var)
		950	else
		951	obj[var[0..-2]]
		952	end
		953	end
		954	end
		955	end
		956
		957	if io.is_a? String
		958	csv.string
		959	else
		960	csv.close
		961	end
		962	end
		963
		964	#
		965	# :call-seq:
		966	# filter( options = Hash.new ) { \|row\| ... }
		967	# filter( input, options = Hash.new ) { \|row\| ... }
		968	# filter( input, output, options = Hash.new ) { \|row\| ... }
		969	#
		970	# This method is a convenience for building Unix-like filters for CSV data.
		971	# Each row is yielded to the provided block which can alter it as needed.
		972	# After the block returns, the row is appended to +output+ altered or not.
		973	#
		974	# The +input+ and +output+ arguments can be anything FasterCSV::new() accepts
		975	# (generally String or IO objects). If not given, they default to
		976	# <tt>ARGF</tt> and <tt>$stdout</tt>.
		977	#
		978	# The +options+ parameter is also filtered down to FasterCSV::new() after some
		979	# clever key parsing. Any key beginning with <tt>:in_</tt> or
		980	# <tt>:input_</tt> will have that leading identifier stripped and will only
		981	# be used in the +options+ Hash for the +input+ object. Keys starting with
		982	# <tt>:out_</tt> or <tt>:output_</tt> affect only +output+. All other keys
		983	# are assigned to both objects.
		984	#
		985	# The <tt>:output_row_sep</tt> +option+ defaults to
		986	# <tt>$INPUT_RECORD_SEPARATOR</tt> (<tt>$/</tt>).
		987	#
		988	def self.filter(*args)
		989	# parse options for input, output, or both
		990	in_options, out_options = Hash.new, {:row_sep => $INPUT_RECORD_SEPARATOR}
		991	if args.last.is_a? Hash
		992	args.pop.each do \|key, value\|
		993	case key.to_s
		994	when /\Ain(?:put)?_(.+)\Z/
		995	in_options[$1.to_sym] = value
		996	when /\Aout(?:put)?_(.+)\Z/
		997	out_options[$1.to_sym] = value
		998	else
		999	in_options[key] = value
		1000	out_options[key] = value
		1001	end
		1002	end
		1003	end
		1004	# build input and output wrappers
		1005	input = FasterCSV.new(args.shift \|\| ARGF, in_options)
		1006	output = FasterCSV.new(args.shift \|\| $stdout, out_options)
		1007
		1008	# read, yield, write
		1009	input.each do \|row\|
		1010	yield row
		1011	output << row
		1012	end
		1013	end
		1014
		1015	#
		1016	# This method is intended as the primary interface for reading CSV files. You
		1017	# pass a +path+ and any +options+ you wish to set for the read. Each row of
		1018	# file will be passed to the provided +block+ in turn.
		1019	#
		1020	# The +options+ parameter can be anything FasterCSV::new() understands.
		1021	#
		1022	def self.foreach(path, options = Hash.new, &block)
		1023	open(path, "rb", options) do \|csv\|
		1024	csv.each(&block)
		1025	end
		1026	end
		1027
		1028	#
		1029	# :call-seq:
		1030	# generate( str, options = Hash.new ) { \|faster_csv\| ... }
		1031	# generate( options = Hash.new ) { \|faster_csv\| ... }
		1032	#
		1033	# This method wraps a String you provide, or an empty default String, in a
		1034	# FasterCSV object which is passed to the provided block. You can use the
		1035	# block to append CSV rows to the String and when the block exits, the
		1036	# final String will be returned.
		1037	#
		1038	# Note that a passed String is modfied by this method. Call dup() before
		1039	# passing if you need a new String.
		1040	#
		1041	# The +options+ parameter can be anthing FasterCSV::new() understands.
		1042	#
		1043	def self.generate(*args)
		1044	# add a default empty String, if none was given
		1045	if args.first.is_a? String
		1046	io = StringIO.new(args.shift)
		1047	io.seek(0, IO::SEEK_END)
		1048	args.unshift(io)
		1049	else
		1050	args.unshift("")
		1051	end
		1052	faster_csv = new(*args) # wrap
		1053	yield faster_csv # yield for appending
		1054	faster_csv.string # return final String
		1055	end
		1056
		1057	#
		1058	# This method is a shortcut for converting a single row (Array) into a CSV
		1059	# String.
		1060	#
		1061	# The +options+ parameter can be anthing FasterCSV::new() understands.
		1062	#
		1063	# The <tt>:row_sep</tt> +option+ defaults to <tt>$INPUT_RECORD_SEPARATOR</tt>
		1064	# (<tt>$/</tt>) when calling this method.
		1065	#
		1066	def self.generate_line(row, options = Hash.new)
		1067	options = {:row_sep => $INPUT_RECORD_SEPARATOR}.merge(options)
		1068	(new("", options) << row).string
		1069	end
		1070
		1071	#
		1072	# This method will return a FasterCSV instance, just like FasterCSV::new(),
		1073	# but the instance will be cached and returned for all future calls to this
		1074	# method for the same +data+ object (tested by Object#object_id()) with the
		1075	# same +options+.
		1076	#
		1077	# If a block is given, the instance is passed to the block and the return
		1078	# value becomes the return value of the block.
		1079	#
		1080	def self.instance(data = $stdout, options = Hash.new)
		1081	# create a _signature_ for this method call, data object and options
		1082	sig = [data.object_id] +
		1083	options.values_at(*DEFAULT_OPTIONS.keys.sort_by { \|sym\| sym.to_s })
		1084
		1085	# fetch or create the instance for this signature
		1086	@@instances \|\|= Hash.new
		1087	instance = (@@instances[sig] \|\|= new(data, options))
		1088
		1089	if block_given?
		1090	yield instance # run block, if given, returning result
		1091	else
		1092	instance # or return the instance
		1093	end
		1094	end
		1095
		1096	#
		1097	# This method is the reading counterpart to FasterCSV::dump(). See that
		1098	# method for a detailed description of the process.
		1099	#
		1100	# You can customize loading by adding a class method called csv_load() which
		1101	# will be passed a Hash of meta information, an Array of headers, and an Array
		1102	# of fields for the object the method is expected to return.
		1103	#
		1104	# Remember that all fields will be Strings after this load. If you need
		1105	# something else, use +options+ to setup converters or provide a custom
		1106	# csv_load() implementation.
		1107	#
		1108	def self.load(io_or_str, options = Hash.new)
		1109	csv = FasterCSV.new(io_or_str, options)
		1110
		1111	# load meta information
		1112	meta = Hash[*csv.shift]
		1113	cls = meta["class"].split("::").inject(Object) do \|c, const\|
		1114	c.const_get(const)
		1115	end
		1116
		1117	# load headers
		1118	headers = csv.shift
		1119
		1120	# unserialize each object stored in the file
		1121	results = csv.inject(Array.new) do \|all, row\|
		1122	begin
		1123	obj = cls.csv_load(meta, headers, row)
		1124	rescue NoMethodError
		1125	obj = cls.allocate
		1126	headers.zip(row) do \|name, value\|
		1127	if name[0] == ?@
		1128	obj.instance_variable_set(name, value)
		1129	else
		1130	obj.send(name, value)
		1131	end
		1132	end
		1133	end
		1134	all << obj
		1135	end
		1136
		1137	csv.close unless io_or_str.is_a? String
		1138
		1139	results
		1140	end
		1141
		1142	#
		1143	# :call-seq:
		1144	# open( filename, mode="rb", options = Hash.new ) { \|faster_csv\| ... }
		1145	# open( filename, mode="rb", options = Hash.new )
		1146	#
		1147	# This method opens an IO object, and wraps that with FasterCSV. This is
		1148	# intended as the primary interface for writing a CSV file.
		1149	#
		1150	# You may pass any +args+ Ruby's open() understands followed by an optional
		1151	# Hash containing any +options+ FasterCSV::new() understands.
		1152	#
		1153	# This method works like Ruby's open() call, in that it will pass a FasterCSV
		1154	# object to a provided block and close it when the block termminates, or it
		1155	# will return the FasterCSV object when no block is provided. (Note: This
		1156	# is different from the standard CSV library which passes rows to the block.
		1157	# Use FasterCSV::foreach() for that behavior.)
		1158	#
		1159	# An opened FasterCSV object will delegate to many IO methods, for
		1160	# convenience. You may call:
		1161	#
		1162	# * binmode()
		1163	# * close()
		1164	# * close_read()
		1165	# * close_write()
		1166	# * closed?()
		1167	# * eof()
		1168	# * eof?()
		1169	# * fcntl()
		1170	# * fileno()
		1171	# * flush()
		1172	# * fsync()
		1173	# * ioctl()
		1174	# * isatty()
		1175	# * pid()
		1176	# * pos()
		1177	# * reopen()
		1178	# * seek()
		1179	# * stat()
		1180	# * sync()
		1181	# * sync=()
		1182	# * tell()
		1183	# * to_i()
		1184	# * to_io()
		1185	# * tty?()
		1186	#
		1187	def self.open(*args)
		1188	# find the +options+ Hash
		1189	options = if args.last.is_a? Hash then args.pop else Hash.new end
		1190	# default to a binary open mode
		1191	args << "rb" if args.size == 1
		1192	# wrap a File opened with the remaining +args+
		1193	csv = new(File.open(*args), options)
		1194
		1195	# handle blocks like Ruby's open(), not like the CSV library
		1196	if block_given?
		1197	begin
		1198	yield csv
		1199	ensure
		1200	csv.close
		1201	end
		1202	else
		1203	csv
		1204	end
		1205	end
		1206
		1207	#
		1208	# :call-seq:
		1209	# parse( str, options = Hash.new ) { \|row\| ... }
		1210	# parse( str, options = Hash.new )
		1211	#
		1212	# This method can be used to easily parse CSV out of a String. You may either
		1213	# provide a +block+ which will be called with each row of the String in turn,
		1214	# or just use the returned Array of Arrays (when no +block+ is given).
		1215	#
		1216	# You pass your +str+ to read from, and an optional +options+ Hash containing
		1217	# anything FasterCSV::new() understands.
		1218	#
		1219	def self.parse(*args, &block)
		1220	csv = new(*args)
		1221	if block.nil? # slurp contents, if no block is given
		1222	begin
		1223	csv.read
		1224	ensure
		1225	csv.close
		1226	end
		1227	else # or pass each row to a provided block
		1228	csv.each(&block)
		1229	end
		1230	end
		1231
		1232	#
		1233	# This method is a shortcut for converting a single line of a CSV String into
		1234	# a into an Array. Note that if +line+ contains multiple rows, anything
		1235	# beyond the first row is ignored.
		1236	#
		1237	# The +options+ parameter can be anthing FasterCSV::new() understands.
		1238	#
		1239	def self.parse_line(line, options = Hash.new)
		1240	new(line, options).shift
		1241	end
		1242
		1243	#
		1244	# Use to slurp a CSV file into an Array of Arrays. Pass the +path+ to the
		1245	# file and any +options+ FasterCSV::new() understands.
		1246	#
		1247	def self.read(path, options = Hash.new)
		1248	open(path, "rb", options) { \|csv\| csv.read }
		1249	end
		1250
		1251	# Alias for FasterCSV::read().
		1252	def self.readlines(*args)
		1253	read(*args)
		1254	end
		1255
		1256	#
		1257	# A shortcut for:
		1258	#
		1259	# FasterCSV.read( path, { :headers => true,
		1260	# :converters => :numeric,
		1261	# :header_converters => :symbol }.merge(options) )
		1262	#
		1263	def self.table(path, options = Hash.new)
		1264	read( path, { :headers => true,
		1265	:converters => :numeric,
		1266	:header_converters => :symbol }.merge(options) )
		1267	end
		1268
		1269	#
		1270	# This constructor will wrap either a String or IO object passed in +data+ for
		1271	# reading and/or writing. In addition to the FasterCSV instance methods,
		1272	# several IO methods are delegated. (See FasterCSV::open() for a complete
		1273	# list.) If you pass a String for +data+, you can later retrieve it (after
		1274	# writing to it, for example) with FasterCSV.string().
		1275	#
		1276	# Note that a wrapped String will be positioned at at the beginning (for
		1277	# reading). If you want it at the end (for writing), use
		1278	# FasterCSV::generate(). If you want any other positioning, pass a preset
		1279	# StringIO object instead.
		1280	#
		1281	# You may set any reading and/or writing preferences in the +options+ Hash.
		1282	# Available options are:
		1283	#
		1284	# <b><tt>:col_sep</tt></b>:: The String placed between each field.
		1285	# <b><tt>:row_sep</tt></b>:: The String appended to the end of each
		1286	# row. This can be set to the special
		1287	# <tt>:auto</tt> setting, which requests
		1288	# that FasterCSV automatically discover
		1289	# this from the data. Auto-discovery
		1290	# reads ahead in the data looking for
		1291	# the next <tt>"\r\n"</tt>,
		1292	# <tt>"\n"</tt>, or <tt>"\r"</tt>
		1293	# sequence. A sequence will be selected
		1294	# even if it occurs in a quoted field,
		1295	# assuming that you would have the same
		1296	# line endings there. If none of those
		1297	# sequences is found, +data+ is
		1298	# <tt>ARGF</tt>, <tt>STDIN</tt>,
		1299	# <tt>STDOUT</tt>, or <tt>STDERR</tt>,
		1300	# or the stream is only available for
		1301	# output, the default
		1302	# <tt>$INPUT_RECORD_SEPARATOR</tt>
		1303	# (<tt>$/</tt>) is used. Obviously,
		1304	# discovery takes a little time. Set
		1305	# manually if speed is important. Also
		1306	# note that IO objects should be opened
		1307	# in binary mode on Windows if this
		1308	# feature will be used as the
		1309	# line-ending translation can cause
		1310	# problems with resetting the document
		1311	# position to where it was before the
		1312	# read ahead.
		1313	# <b><tt>:quote_char</tt></b>:: The character used to quote fields.
		1314	# This has to be a single character
		1315	# String. This is useful for
		1316	# application that incorrectly use
		1317	# <tt>'</tt> as the quote character
		1318	# instead of the correct <tt>"</tt>.
		1319	# FasterCSV will always consider a
		1320	# double sequence this character to be
		1321	# an escaped quote.
		1322	# <b><tt>:encoding</tt></b>:: The encoding to use when parsing the
		1323	# file. Defaults to your <tt>$KDOCE</tt>
		1324	# setting. Valid values: <tt>`n’</tt> or
		1325	# <tt>`N’</tt> for none, <tt>`e’</tt> or
		1326	# <tt>`E’</tt> for EUC, <tt>`s’</tt> or
		1327	# <tt>`S’</tt> for SJIS, and
		1328	# <tt>`u’</tt> or <tt>`U’</tt> for UTF-8
		1329	# (see Regexp.new()).
		1330	# <b><tt>:field_size_limit</tt></b>:: This is a maximum size FasterCSV will
		1331	# read ahead looking for the closing
		1332	# quote for a field. (In truth, it
		1333	# reads to the first line ending beyond
		1334	# this size.) If a quote cannot be
		1335	# found within the limit FasterCSV will
		1336	# raise a MalformedCSVError, assuming
		1337	# the data is faulty. You can use this
		1338	# limit to prevent what are effectively
		1339	# DoS attacks on the parser. However,
		1340	# this limit can cause a legitimate
		1341	# parse to fail and thus is set to
		1342	# +nil+, or off, by default.
		1343	# <b><tt>:converters</tt></b>:: An Array of names from the Converters
		1344	# Hash and/or lambdas that handle custom
		1345	# conversion. A single converter
		1346	# doesn't have to be in an Array.
		1347	# <b><tt>:unconverted_fields</tt></b>:: If set to +true+, an
		1348	# unconverted_fields() method will be
		1349	# added to all returned rows (Array or
		1350	# FasterCSV::Row) that will return the
		1351	# fields as they were before convertion.
		1352	# Note that <tt>:headers</tt> supplied
		1353	# by Array or String were not fields of
		1354	# the document and thus will have an
		1355	# empty Array attached.
		1356	# <b><tt>:headers</tt></b>:: If set to <tt>:first_row</tt> or
		1357	# +true+, the initial row of the CSV
		1358	# file will be treated as a row of
		1359	# headers. If set to an Array, the
		1360	# contents will be used as the headers.
		1361	# If set to a String, the String is run
		1362	# through a call of
		1363	# FasterCSV::parse_line() with the same
		1364	# <tt>:col_sep</tt>, <tt>:row_sep</tt>,
		1365	# and <tt>:quote_char</tt> as this
		1366	# instance to produce an Array of
		1367	# headers. This setting causes
		1368	# FasterCSV.shift() to return rows as
		1369	# FasterCSV::Row objects instead of
		1370	# Arrays and FasterCSV.read() to return
		1371	# FasterCSV::Table objects instead of
		1372	# an Array of Arrays.
		1373	# <b><tt>:return_headers</tt></b>:: When +false+, header rows are silently
		1374	# swallowed. If set to +true+, header
		1375	# rows are returned in a FasterCSV::Row
		1376	# object with identical headers and
		1377	# fields (save that the fields do not go
		1378	# through the converters).
		1379	# <b><tt>:write_headers</tt></b>:: When +true+ and <tt>:headers</tt> is
		1380	# set, a header row will be added to the
		1381	# output.
		1382	# <b><tt>:header_converters</tt></b>:: Identical in functionality to
		1383	# <tt>:converters</tt> save that the
		1384	# conversions are only made to header
		1385	# rows.
		1386	# <b><tt>:skip_blanks</tt></b>:: When set to a +true+ value, FasterCSV
		1387	# will skip over any rows with no
		1388	# content.
		1389	# <b><tt>:force_quotes</tt></b>:: When set to a +true+ value, FasterCSV
		1390	# will quote all CSV fields it creates.
		1391	#
		1392	# See FasterCSV::DEFAULT_OPTIONS for the default settings.
		1393	#
		1394	# Options cannot be overriden in the instance methods for performance reasons,
		1395	# so be sure to set what you want here.
		1396	#
		1397	def initialize(data, options = Hash.new)
		1398	# build the options for this read/write
		1399	options = DEFAULT_OPTIONS.merge(options)
		1400
		1401	# create the IO object we will read from
		1402	@io = if data.is_a? String then StringIO.new(data) else data end
		1403
		1404	init_separators(options)
		1405	init_parsers(options)
		1406	init_converters(options)
		1407	init_headers(options)
		1408
		1409	unless options.empty?
		1410	raise ArgumentError, "Unknown options: #{options.keys.join(', ')}."
		1411	end
		1412
		1413	# track our own lineno since IO gets confused about line-ends is CSV fields
		1414	@lineno = 0
		1415	end
		1416
		1417	#
		1418	# The line number of the last row read from this file. Fields with nested
		1419	# line-end characters will not affect this count.
		1420	#
		1421	attr_reader :lineno
		1422
		1423	### IO and StringIO Delegation ###
		1424
		1425	extend Forwardable
		1426	def_delegators :@io, :binmode, :close, :close_read, :close_write, :closed?,
		1427	:eof, :eof?, :fcntl, :fileno, :flush, :fsync, :ioctl,
		1428	:isatty, :pid, :pos, :reopen, :seek, :stat, :string,
		1429	:sync, :sync=, :tell, :to_i, :to_io, :tty?
		1430
		1431	# Rewinds the underlying IO object and resets FasterCSV's lineno() counter.
		1432	def rewind
		1433	@headers = nil
		1434	@lineno = 0
		1435
		1436	@io.rewind
		1437	end
		1438
		1439	### End Delegation ###
		1440
		1441	#
		1442	# The primary write method for wrapped Strings and IOs, +row+ (an Array or
		1443	# FasterCSV::Row) is converted to CSV and appended to the data source. When a
		1444	# FasterCSV::Row is passed, only the row's fields() are appended to the
		1445	# output.
		1446	#
		1447	# The data source must be open for writing.
		1448	#
		1449	def <<(row)
		1450	# make sure headers have been assigned
		1451	if header_row? and [Array, String].include? @use_headers.class
		1452	parse_headers # won't read data for Array or String
		1453	self << @headers if @write_headers
		1454	end
		1455
		1456	# Handle FasterCSV::Row objects and Hashes
		1457	row = case row
		1458	when self.class::Row then row.fields
		1459	when Hash then @headers.map { \|header\| row[header] }
		1460	else row
		1461	end
		1462
		1463	@headers = row if header_row?
		1464	@lineno += 1
		1465
		1466	@io << row.map(&@quote).join(@col_sep) + @row_sep # quote and separate
		1467
		1468	self # for chaining
		1469	end
		1470	alias_method :add_row, :<<
		1471	alias_method :puts, :<<
		1472
		1473	#
		1474	# :call-seq:
		1475	# convert( name )
		1476	# convert { \|field\| ... }
		1477	# convert { \|field, field_info\| ... }
		1478	#
		1479	# You can use this method to install a FasterCSV::Converters built-in, or
		1480	# provide a block that handles a custom conversion.
		1481	#
		1482	# If you provide a block that takes one argument, it will be passed the field
		1483	# and is expected to return the converted value or the field itself. If your
		1484	# block takes two arguments, it will also be passed a FieldInfo Struct,
		1485	# containing details about the field. Again, the block should return a
		1486	# converted field or the field itself.
		1487	#
		1488	def convert(name = nil, &converter)
		1489	add_converter(:converters, self.class::Converters, name, &converter)
		1490	end
		1491
		1492	#
		1493	# :call-seq:
		1494	# header_convert( name )
		1495	# header_convert { \|field\| ... }
		1496	# header_convert { \|field, field_info\| ... }
		1497	#
		1498	# Identical to FasterCSV.convert(), but for header rows.
		1499	#
		1500	# Note that this method must be called before header rows are read to have any
		1501	# effect.
		1502	#
		1503	def header_convert(name = nil, &converter)
		1504	add_converter( :header_converters,
		1505	self.class::HeaderConverters,
		1506	name,
		1507	&converter )
		1508	end
		1509
		1510	include Enumerable
		1511
		1512	#
		1513	# Yields each row of the data source in turn.
		1514	#
		1515	# Support for Enumerable.
		1516	#
		1517	# The data source must be open for reading.
		1518	#
		1519	def each
		1520	while row = shift
		1521	yield row
		1522	end
		1523	end
		1524
		1525	#
		1526	# Slurps the remaining rows and returns an Array of Arrays.
		1527	#
		1528	# The data source must be open for reading.
		1529	#
		1530	def read
		1531	rows = to_a
		1532	if @use_headers
		1533	Table.new(rows)
		1534	else
		1535	rows
		1536	end
		1537	end
		1538	alias_method :readlines, :read
		1539
		1540	# Returns +true+ if the next row read will be a header row.
		1541	def header_row?
		1542	@use_headers and @headers.nil?
		1543	end
		1544
		1545	#
		1546	# The primary read method for wrapped Strings and IOs, a single row is pulled
		1547	# from the data source, parsed and returned as an Array of fields (if header
		1548	# rows are not used) or a FasterCSV::Row (when header rows are used).
		1549	#
		1550	# The data source must be open for reading.
		1551	#
		1552	def shift
		1553	#########################################################################
		1554	### This method is purposefully kept a bit long as simple conditional ###
		1555	### checks are faster than numerous (expensive) method calls. ###
		1556	#########################################################################
		1557
		1558	# handle headers not based on document content
		1559	if header_row? and @return_headers and
		1560	[Array, String].include? @use_headers.class
		1561	if @unconverted_fields
		1562	return add_unconverted_fields(parse_headers, Array.new)
		1563	else
		1564	return parse_headers
		1565	end
		1566	end
		1567
		1568	# begin with a blank line, so we can always add to it
		1569	line = String.new
		1570
		1571	#
		1572	# it can take multiple calls to <tt>@io.gets()</tt> to get a full line,
		1573	# because of \r and/or \n characters embedded in quoted fields
		1574	#
		1575	loop do
		1576	# add another read to the line
		1577	begin
		1578	line += @io.gets(@row_sep)
		1579	rescue
		1580	return nil
		1581	end
		1582	# copy the line so we can chop it up in parsing
		1583	parse = line.dup
		1584	parse.sub!(@parsers[:line_end], "")
		1585
		1586	#
		1587	# I believe a blank line should be an <tt>Array.new</tt>, not
		1588	# CSV's <tt>[nil]</tt>
		1589	#
		1590	if parse.empty?
		1591	@lineno += 1
		1592	if @skip_blanks
		1593	line = ""
		1594	next
		1595	elsif @unconverted_fields
		1596	return add_unconverted_fields(Array.new, Array.new)
		1597	elsif @use_headers
		1598	return FasterCSV::Row.new(Array.new, Array.new)
		1599	else
		1600	return Array.new
		1601	end
		1602	end
		1603
		1604	# parse the fields with a mix of String#split and regular expressions
		1605	csv = Array.new
		1606	current_field = String.new
		1607	field_quotes = 0
		1608	parse.split(@col_sep, -1).each do \|match\|
		1609	if current_field.empty? && match.count(@quote_and_newlines).zero?
		1610	csv << (match.empty? ? nil : match)
		1611	elsif(current_field.empty? ? match[0] : current_field[0]) == @quote_char[0]
		1612	current_field << match
		1613	field_quotes += match.count(@quote_char)
		1614	if field_quotes % 2 == 0
		1615	in_quotes = current_field[@parsers[:quoted_field], 1]
		1616	raise MalformedCSVError unless in_quotes
		1617	current_field = in_quotes
		1618	current_field.gsub!(@quote_char * 2, @quote_char) # unescape contents
		1619	csv << current_field
		1620	current_field = String.new
		1621	field_quotes = 0
		1622	else # we found a quoted field that spans multiple lines
		1623	current_field << @col_sep
		1624	end
		1625	elsif match.count("\r\n").zero?
		1626	raise MalformedCSVError, "Illegal quoting on line #{lineno + 1}."
		1627	else
		1628	raise MalformedCSVError, "Unquoted fields do not allow " +
		1629	"\\r or \\n (line #{lineno + 1})."
		1630	end
		1631	end
		1632
		1633	# if parse is empty?(), we found all the fields on the line...
		1634	if field_quotes % 2 == 0
		1635	@lineno += 1
		1636
		1637	# save fields unconverted fields, if needed...
		1638	unconverted = csv.dup if @unconverted_fields
		1639
		1640	# convert fields, if needed...
		1641	csv = convert_fields(csv) unless @use_headers or @converters.empty?
		1642	# parse out header rows and handle FasterCSV::Row conversions...
		1643	csv = parse_headers(csv) if @use_headers
		1644
		1645	# inject unconverted fields and accessor, if requested...
		1646	if @unconverted_fields and not csv.respond_to? :unconverted_fields
		1647	add_unconverted_fields(csv, unconverted)
		1648	end
		1649
		1650	# return the results
		1651	break csv
		1652	end
		1653	# if we're not empty?() but at eof?(), a quoted field wasn't closed...
		1654	if @io.eof?
		1655	raise MalformedCSVError, "Unclosed quoted field on line #{lineno + 1}."
		1656	elsif @field_size_limit and current_field.size >= @field_size_limit
		1657	raise MalformedCSVError, "Field size exceeded on line #{lineno + 1}."
		1658	end
		1659	# otherwise, we need to loop and pull some more data to complete the row
		1660	end
		1661	end
		1662	alias_method :gets, :shift
		1663	alias_method :readline, :shift
		1664
		1665	# Returns a simplified description of the key FasterCSV attributes.
		1666	def inspect
		1667	str = "<##{self.class} io_type:"
		1668	# show type of wrapped IO
		1669	if @io == $stdout then str << "$stdout"
		1670	elsif @io == $stdin then str << "$stdin"
		1671	elsif @io == $stderr then str << "$stderr"
		1672	else str << @io.class.to_s
		1673	end
		1674	# show IO.path(), if available
		1675	if @io.respond_to?(:path) and (p = @io.path)
		1676	str << " io_path:#{p.inspect}"
		1677	end
		1678	# show other attributes
		1679	%w[ lineno col_sep row_sep
		1680	quote_char skip_blanks encoding ].each do \|attr_name\|
		1681	if a = instance_variable_get("@#{attr_name}")
		1682	str << " #{attr_name}:#{a.inspect}"
		1683	end
		1684	end
		1685	if @use_headers
		1686	str << " headers:#{(@headers \|\| true).inspect}"
		1687	end
		1688	str << ">"
		1689	end
		1690
		1691	private
		1692
		1693	#
		1694	# Stores the indicated separators for later use.
		1695	#
		1696	# If auto-discovery was requested for <tt>@row_sep</tt>, this method will read
		1697	# ahead in the <tt>@io</tt> and try to find one. +ARGF+, +STDIN+, +STDOUT+,
		1698	# +STDERR+ and any stream open for output only with a default
		1699	# <tt>@row_sep</tt> of <tt>$INPUT_RECORD_SEPARATOR</tt> (<tt>$/</tt>).
		1700	#
		1701	# This method also establishes the quoting rules used for CSV output.
		1702	#
		1703	def init_separators(options)
		1704	# store the selected separators
		1705	@col_sep = options.delete(:col_sep)
		1706	@row_sep = options.delete(:row_sep)
		1707	@quote_char = options.delete(:quote_char)
		1708	@quote_and_newlines = "#{@quote_char}\r\n"
		1709
		1710	if @quote_char.length != 1
		1711	raise ArgumentError, ":quote_char has to be a single character String"
		1712	end
		1713
		1714	# automatically discover row separator when requested
		1715	if @row_sep == :auto
		1716	if [ARGF, STDIN, STDOUT, STDERR].include?(@io) or
		1717	(defined?(Zlib) and @io.class == Zlib::GzipWriter)
		1718	@row_sep = $INPUT_RECORD_SEPARATOR
		1719	else
		1720	begin
		1721	saved_pos = @io.pos # remember where we were
		1722	while @row_sep == :auto
		1723	#
		1724	# if we run out of data, it's probably a single line
		1725	# (use a sensible default)
		1726	#
		1727	if @io.eof?
		1728	@row_sep = $INPUT_RECORD_SEPARATOR
		1729	break
		1730	end
		1731
		1732	# read ahead a bit
		1733	sample = @io.read(1024)
		1734	sample += @io.read(1) if sample[-1..-1] == "\r" and not @io.eof?
		1735
		1736	# try to find a standard separator
		1737	if sample =~ /\r\n?\|\n/
		1738	@row_sep = $&
		1739	break
		1740	end
		1741	end
		1742	# tricky seek() clone to work around GzipReader's lack of seek()
		1743	@io.rewind
		1744	# reset back to the remembered position
		1745	while saved_pos > 1024 # avoid loading a lot of data into memory
		1746	@io.read(1024)
		1747	saved_pos -= 1024
		1748	end
		1749	@io.read(saved_pos) if saved_pos.nonzero?
		1750	rescue IOError # stream not opened for reading
		1751	@row_sep = $INPUT_RECORD_SEPARATOR
		1752	end
		1753	end
		1754	end
		1755
		1756	# establish quoting rules
		1757	do_quote = lambda do \|field\|
		1758	@quote_char +
		1759	String(field).gsub(@quote_char, @quote_char * 2) +
		1760	@quote_char
		1761	end
		1762	@quote = if options.delete(:force_quotes)
		1763	do_quote
		1764	else
		1765	lambda do \|field\|
		1766	if field.nil? # represent +nil+ fields as empty unquoted fields
		1767	""
		1768	else
		1769	field = String(field) # Stringify fields
		1770	# represent empty fields as empty quoted fields
		1771	if field.empty? or
		1772	field.count("\r\n#{@col_sep}#{@quote_char}").nonzero?
		1773	do_quote.call(field)
		1774	else
		1775	field # unquoted field
		1776	end
		1777	end
		1778	end
		1779	end
		1780	end
		1781
		1782	# Pre-compiles parsers and stores them by name for access during reads.
		1783	def init_parsers(options)
		1784	# store the parser behaviors
		1785	@skip_blanks = options.delete(:skip_blanks)
		1786	@encoding = options.delete(:encoding) # nil will use $KCODE
		1787	@field_size_limit = options.delete(:field_size_limit)
		1788
		1789	# prebuild Regexps for faster parsing
		1790	esc_col_sep = Regexp.escape(@col_sep)
		1791	esc_row_sep = Regexp.escape(@row_sep)
		1792	esc_quote = Regexp.escape(@quote_char)
		1793	@parsers = {
		1794	:any_field => Regexp.new( "[^#{esc_col_sep}]+",
		1795	Regexp::MULTILINE,
		1796	@encoding ),
		1797	:quoted_field => Regexp.new( "^#{esc_quote}(.*)#{esc_quote}$",
		1798	Regexp::MULTILINE,
		1799	@encoding ),
		1800	# safer than chomp!()
		1801	:line_end => Regexp.new("#{esc_row_sep}\\z", nil, @encoding)
		1802	}
		1803	end
		1804
		1805	#
		1806	# Loads any converters requested during construction.
		1807	#
		1808	# If +field_name+ is set <tt>:converters</tt> (the default) field converters
		1809	# are set. When +field_name+ is <tt>:header_converters</tt> header converters
		1810	# are added instead.
		1811	#
		1812	# The <tt>:unconverted_fields</tt> option is also actived for
		1813	# <tt>:converters</tt> calls, if requested.
		1814	#
		1815	def init_converters(options, field_name = :converters)
		1816	if field_name == :converters
		1817	@unconverted_fields = options.delete(:unconverted_fields)
		1818	end
		1819
		1820	instance_variable_set("@#{field_name}", Array.new)
		1821
		1822	# find the correct method to add the coverters
		1823	convert = method(field_name.to_s.sub(/ers\Z/, ""))
		1824
		1825	# load converters
		1826	unless options[field_name].nil?
		1827	# allow a single converter not wrapped in an Array
		1828	unless options[field_name].is_a? Array
		1829	options[field_name] = [options[field_name]]
		1830	end
		1831	# load each converter...
		1832	options[field_name].each do \|converter\|
		1833	if converter.is_a? Proc # custom code block
		1834	convert.call(&converter)
		1835	else # by name
		1836	convert.call(converter)
		1837	end
		1838	end
		1839	end
		1840
		1841	options.delete(field_name)
		1842	end
		1843
		1844	# Stores header row settings and loads header converters, if needed.
		1845	def init_headers(options)
		1846	@use_headers = options.delete(:headers)
		1847	@return_headers = options.delete(:return_headers)
		1848	@write_headers = options.delete(:write_headers)
		1849
		1850	# headers must be delayed until shift(), in case they need a row of content
		1851	@headers = nil
		1852
		1853	init_converters(options, :header_converters)
		1854	end
		1855
		1856	#
		1857	# The actual work method for adding converters, used by both
		1858	# FasterCSV.convert() and FasterCSV.header_convert().
		1859	#
		1860	# This method requires the +var_name+ of the instance variable to place the
		1861	# converters in, the +const+ Hash to lookup named converters in, and the
		1862	# normal parameters of the FasterCSV.convert() and FasterCSV.header_convert()
		1863	# methods.
		1864	#
		1865	def add_converter(var_name, const, name = nil, &converter)
		1866	if name.nil? # custom converter
		1867	instance_variable_get("@#{var_name}") << converter
		1868	else # named converter
		1869	combo = const[name]
		1870	case combo
		1871	when Array # combo converter
		1872	combo.each do \|converter_name\|
		1873	add_converter(var_name, const, converter_name)
		1874	end
		1875	else # individual named converter
		1876	instance_variable_get("@#{var_name}") << combo
		1877	end
		1878	end
		1879	end
		1880
		1881	#
		1882	# Processes +fields+ with <tt>@converters</tt>, or <tt>@header_converters</tt>
		1883	# if +headers+ is passed as +true+, returning the converted field set. Any
		1884	# converter that changes the field into something other than a String halts
		1885	# the pipeline of conversion for that field. This is primarily an efficiency
		1886	# shortcut.
		1887	#
		1888	def convert_fields(fields, headers = false)
		1889	# see if we are converting headers or fields
		1890	converters = headers ? @header_converters : @converters
		1891
		1892	fields.enum_for(:each_with_index).map do \|field, index\| # map_with_index
		1893	converters.each do \|converter\|
		1894	field = if converter.arity == 1 # straight field converter
		1895	converter[field]
		1896	else # FieldInfo converter
		1897	header = @use_headers && !headers ? @headers[index] : nil
		1898	converter[field, FieldInfo.new(index, lineno, header)]
		1899	end
		1900	break unless field.is_a? String # short-curcuit pipeline for speed
		1901	end
		1902	field # return final state of each field, converted or original
		1903	end
		1904	end
		1905
		1906	#
		1907	# This methods is used to turn a finished +row+ into a FasterCSV::Row. Header
		1908	# rows are also dealt with here, either by returning a FasterCSV::Row with
		1909	# identical headers and fields (save that the fields do not go through the
		1910	# converters) or by reading past them to return a field row. Headers are also
		1911	# saved in <tt>@headers</tt> for use in future rows.
		1912	#
		1913	# When +nil+, +row+ is assumed to be a header row not based on an actual row
		1914	# of the stream.
		1915	#
		1916	def parse_headers(row = nil)
		1917	if @headers.nil? # header row
		1918	@headers = case @use_headers # save headers
		1919	# Array of headers
		1920	when Array then @use_headers
		1921	# CSV header String
		1922	when String
		1923	self.class.parse_line( @use_headers,
		1924	:col_sep => @col_sep,
		1925	:row_sep => @row_sep,
		1926	:quote_char => @quote_char )
		1927	# first row is headers
		1928	else row
		1929	end
		1930
		1931	# prepare converted and unconverted copies
		1932	row = @headers if row.nil?
		1933	@headers = convert_fields(@headers, true)
		1934
		1935	if @return_headers # return headers
		1936	return FasterCSV::Row.new(@headers, row, true)
		1937	elsif not [Array, String].include? @use_headers.class # skip to field row
		1938	return shift
		1939	end
		1940	end
		1941
		1942	FasterCSV::Row.new(@headers, convert_fields(row)) # field row
		1943	end
		1944
		1945	#
		1946	# Thiw methods injects an instance variable <tt>unconverted_fields</tt> into
		1947	# +row+ and an accessor method for it called unconverted_fields(). The
		1948	# variable is set to the contents of +fields+.
		1949	#
		1950	def add_unconverted_fields(row, fields)
		1951	class << row
		1952	attr_reader :unconverted_fields
		1953	end
		1954	row.instance_eval { @unconverted_fields = fields }
		1955	row
		1956	end
		1957	end
		1958
		1959	# Another name for FasterCSV.
		1960	FCSV = FasterCSV
		1961
		1962	# Another name for FasterCSV::instance().
		1963	def FasterCSV(*args, &block)
		1964	FasterCSV.instance(*args, &block)
		1965	end
		1966
		1967	# Another name for FCSV::instance().
		1968	def FCSV(*args, &block)
		1969	FCSV.instance(*args, &block)
		1970	end
		1971
		1972	class Array
		1973	# Equivalent to <tt>FasterCSV::generate_line(self, options)</tt>.
		1974	def to_csv(options = Hash.new)
		1975	FasterCSV.generate_line(self, options)
		1976	end
		1977	end
		1978
		1979	class String
		1980	# Equivalent to <tt>FasterCSV::parse_line(self, options)</tt>.
		1981	def parse_csv(options = Hash.new)
		1982	FasterCSV.parse_line(self, options)
		1983	end
		1984	end

app/controllers/issues_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2008  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class IssuesController < ApplicationController
               menu_item :new_issue, :only => :new
               default_search_scope :issues
               before_filter :find_issue, :only => [:show, :edit, :reply]
               before_filter :find_issues, :only => [:bulk_edit, :move, :destroy]
               before_filter :find_project, :only => [:new, :update_form, :preview]
               before_filter :authorize, :except => [:index, :changes, :gantt, :calendar, :preview, :update_form, :context_menu]
               before_filter :find_optional_project, :only => [:index, :changes, :gantt, :calendar]
               accept_key_auth :index, :show, :changes
               helper :journals
               helper :projects
               include ProjectsHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issue_relations
               include IssueRelationsHelper
               helper :watchers
               include WatchersHelper
               helper :attachments
               include AttachmentsHelper
               helper :queries
               helper :sort
               include SortHelper
               include IssuesHelper
               helper :timelog
               include Redmine::Export::PDF
               verify :method => :post,
                      :only => :destroy,
                      :render => { :nothing => true, :status => :method_not_allowed }
               def index
                 retrieve_query
                 sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                 sort_update({'id' => "#{Issue.table_name}.id"}.merge(@query.available_columns.inject({}) {|h, c| h[c.name.to_s] = c.sortable; h}))
                 if @query.valid?
                   limit = per_page_option
                   respond_to do |format|
                     format.html { }
                     format.atom { limit = Setting.feeds_limit.to_i }
                     format.csv  { limit = Setting.issues_export_limit.to_i }
                     format.pdf  { limit = Setting.issues_export_limit.to_i }
                   end
                   @issue_count = Issue.count(:include => [:status, :project], :conditions => @query.statement)
                   @issue_pages = Paginator.new self, @issue_count, limit, params['page']
                   @issues = Issue.find :all, :order => [@query.group_by_sort_order, sort_clause].compact.join(','),
                                        :include => [ :assigned_to, :status, :tracker, :project, :priority, :category, :fixed_version ],
                                        :conditions => @query.statement,
                                        :limit  =>  limit,
                                        :offset =>  @issue_pages.current.offset
                   respond_to do |format|
                     format.html {
                       if @query.grouped?
                         # Retrieve the issue count by group
                         @issue_count_by_group = begin
                           Issue.count(:group => @query.group_by, :include => [:status, :project], :conditions => @query.statement)
                         # Rails will raise an (unexpected) error if there's only a nil group value
                         rescue ActiveRecord::RecordNotFound
                           {nil => @issue_count}
                         end
                       end
                       render :template => 'issues/index.rhtml', :layout => !request.xhr?
                     }
                     format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
-                    format.csv  { send_data(issues_to_csv(@issues, @project).read, :type => 'text/csv; header=present', :filename => 'export.csv') }
+                    format.csv  { send_data(issues_to_csv(@issues, @project), :type => 'text/csv; header=present', :filename => 'export.csv') }
                     format.pdf  { send_data(issues_to_pdf(@issues, @project, @query), :type => 'application/pdf', :filename => 'export.pdf') }
                   end
                 else
                   # Send html if the query is not valid
                   render(:template => 'issues/index.rhtml', :layout => !request.xhr?)
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def changes
                 retrieve_query
                 sort_init 'id', 'desc'
                 sort_update({'id' => "#{Issue.table_name}.id"}.merge(@query.available_columns.inject({}) {|h, c| h[c.name.to_s] = c.sortable; h}))
                 if @query.valid?
                   @journals = Journal.find :all, :include => [ :details, :user, {:issue => [:project, :author, :tracker, :status]} ],
                                                  :conditions => @query.statement,
                                                  :limit => 25,
                                                  :order => "#{Journal.table_name}.created_on DESC"
                 end
                 @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)
                 render :layout => false, :content_type => 'application/atom+xml'
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def show
                 @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                 @journals.each_with_index {|j,i| j.indice = i+1}
                 @journals.reverse! if User.current.wants_comments_in_reverse_order?
                 @changesets = @issue.changesets
                 @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @priorities = IssuePriority.all
                 @time_entry = TimeEntry.new
                 respond_to do |format|
                   format.html { render :template => 'issues/show.rhtml' }
                   format.atom { render :action => 'changes', :layout => false, :content_type => 'application/atom+xml' }
                   format.pdf  { send_data(issue_to_pdf(@issue), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                 end
               end
               # Add a new issue
               # The new issue will be created from an existing one if copy_from parameter is given
               def new
                 @issue = Issue.new
                 @issue.copy_from(params[:copy_from]) if params[:copy_from]
                 @issue.project = @project
                 # Tracker must be set before custom field values
                 @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)
                 if @issue.tracker.nil?
                   render_error l(:error_no_tracker_in_project)
                   return
                 end
                 if params[:issue].is_a?(Hash)
                   @issue.attributes = params[:issue]
                   @issue.watcher_user_ids = params[:issue]['watcher_user_ids'] if User.current.allowed_to?(:add_issue_watchers, @project)
                 end
                 @issue.author = User.current
                 default_status = IssueStatus.default
                 unless default_status
                   render_error l(:error_no_default_issue_status)
                   return
                 end
                 @issue.status = default_status
                 @allowed_statuses = ([default_status] + default_status.find_new_statuses_allowed_to(User.current.roles_for_project(@project), @issue.tracker)).uniq
                 if request.get? || request.xhr?
                   @issue.start_date ||= Date.today
                 else
                   requested_status = IssueStatus.find_by_id(params[:issue][:status_id])
                   # Check that the user is allowed to apply the requested status
                   @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status
                   if @issue.save
                     attach_files(@issue, params[:attachments])
                     flash[:notice] = l(:notice_successful_create)
                     call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                     redirect_to(params[:continue] ? { :action => 'new', :tracker_id => @issue.tracker } :
                                                     { :action => 'show', :id => @issue })
                     return
                   end
                 end
                 @priorities = IssuePriority.all
                 render :layout => !request.xhr?
               end
               # Attributes that can be updated on workflow transition (without :edit permission)
               # TODO: make it configurable (at least per role)
               UPDATABLE_ATTRS_ON_TRANSITION = %w(status_id assigned_to_id fixed_version_id done_ratio) unless const_defined?(:UPDATABLE_ATTRS_ON_TRANSITION)
               def edit
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @priorities = IssuePriority.all
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @time_entry = TimeEntry.new
                 @notes = params[:notes]
                 journal = @issue.init_journal(User.current, @notes)
                 # User can change issue attributes only if he has :edit permission or if a workflow transition is allowed
                 if (@edit_allowed || !@allowed_statuses.empty?) && params[:issue]
                   attrs = params[:issue].dup
                   attrs.delete_if {|k,v| !UPDATABLE_ATTRS_ON_TRANSITION.include?(k) } unless @edit_allowed
                   attrs.delete(:status_id) unless @allowed_statuses.detect {|s| s.id.to_s == attrs[:status_id].to_s}
                   @issue.attributes = attrs
                 end
                 if request.post?
                   @time_entry = TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
                   @time_entry.attributes = params[:time_entry]
                   attachments = attach_files(@issue, params[:attachments])
                   attachments.each {|a| journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
                   call_hook(:controller_issues_edit_before_save, { :params => params, :issue => @issue, :time_entry => @time_entry, :journal => journal})
                   if (@time_entry.hours.nil? || @time_entry.valid?) && @issue.save
                     # Log spend time
                     if User.current.allowed_to?(:log_time, @project)
                       @time_entry.save
                     end
                     if !journal.new_record?
                       # Only send notification if something was actually changed
                       flash[:notice] = l(:notice_successful_update)
                     end
                     call_hook(:controller_issues_edit_after_save, { :params => params, :issue => @issue, :time_entry => @time_entry, :journal => journal})
                     redirect_to(params[:back_to] || {:action => 'show', :id => @issue})
                   end
                 end
               rescue ActiveRecord::StaleObjectError
                 # Optimistic locking exception
                 flash.now[:error] = l(:notice_locking_conflict)
                 # Remove the previously added attachments if issue was not updated
                 attachments.each(&:destroy)
               end
               def reply
                 journal = Journal.find(params[:journal_id]) if params[:journal_id]
                 if journal
                   user = journal.user
                   text = journal.notes
                 else
                   user = @issue.author
                   text = @issue.description
                 end
                 content = "#{ll(Setting.default_language, :text_user_wrote, user)}\\n> "
                 content << text.to_s.strip.gsub(%r{<pre>((.|\s)*?)</pre>}m, '[...]').gsub('"', '\"').gsub(/(\r?\n|\r\n?)/, "\\n> ") + "\\n\\n"
                 render(:update) { |page|
                   page.<< "$('notes').value = \"#{content}\";"
                   page.show 'update'
                   page << "Form.Element.focus('notes');"
                   page << "Element.scrollTo('update');"
                   page << "$('notes').scrollTop = $('notes').scrollHeight - $('notes').clientHeight;"
                 }
               end
               # Bulk edit a set of issues
               def bulk_edit
                 if request.post?
                   status = params[:status_id].blank? ? nil : IssueStatus.find_by_id(params[:status_id])
                   priority = params[:priority_id].blank? ? nil : IssuePriority.find_by_id(params[:priority_id])
                   assigned_to = (params[:assigned_to_id].blank? || params[:assigned_to_id] == 'none') ? nil : User.find_by_id(params[:assigned_to_id])
                   category = (params[:category_id].blank? || params[:category_id] == 'none') ? nil : @project.issue_categories.find_by_id(params[:category_id])
                   fixed_version = (params[:fixed_version_id].blank? || params[:fixed_version_id] == 'none') ? nil : @project.versions.find_by_id(params[:fixed_version_id])
                   custom_field_values = params[:custom_field_values] ? params[:custom_field_values].reject {|k,v| v.blank?} : nil
                   unsaved_issue_ids = []
                   @issues.each do |issue|
                     journal = issue.init_journal(User.current, params[:notes])
                     issue.priority = priority if priority
                     issue.assigned_to = assigned_to if assigned_to || params[:assigned_to_id] == 'none'
                     issue.category = category if category || params[:category_id] == 'none'
                     issue.fixed_version = fixed_version if fixed_version || params[:fixed_version_id] == 'none'
                     issue.start_date = params[:start_date] unless params[:start_date].blank?
                     issue.due_date = params[:due_date] unless params[:due_date].blank?
                     issue.done_ratio = params[:done_ratio] unless params[:done_ratio].blank?
                     issue.custom_field_values = custom_field_values if custom_field_values && !custom_field_values.empty?
                     call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                     # Don't save any change to the issue if the user is not authorized to apply the requested status
                     unless (status.nil? || (issue.new_statuses_allowed_to(User.current).include?(status) && issue.status = status)) && issue.save
                       # Keep unsaved issue ids to display them in flash error
                       unsaved_issue_ids << issue.id
                     end
                   end
                   if unsaved_issue_ids.empty?
                     flash[:notice] = l(:notice_successful_update) unless @issues.empty?
                   else
                     flash[:error] = l(:notice_failed_to_save_issues, :count => unsaved_issue_ids.size,
                                                                      :total => @issues.size,
                                                                      :ids => '#' + unsaved_issue_ids.join(', #'))
                   end
                   redirect_to(params[:back_to] || {:controller => 'issues', :action => 'index', :project_id => @project})
                   return
                 end
                 # Find potential statuses the user could be allowed to switch issues to
                 @available_statuses = Workflow.find(:all, :include => :new_status,
                                                           :conditions => {:role_id => User.current.roles_for_project(@project).collect(&:id)}).collect(&:new_status).compact.uniq.sort
                 @custom_fields = @project.issue_custom_fields.select {|f| f.field_format == 'list'}
               end
               def move
                 @allowed_projects = []
                 # find projects to which the user is allowed to move the issue
                 if User.current.admin?
                   # admin is allowed to move issues to any active (visible) project
                   @allowed_projects = Project.find(:all, :conditions => Project.visible_by(User.current))
                 else
                   User.current.memberships.each {|m| @allowed_projects << m.project if m.roles.detect {|r| r.allowed_to?(:move_issues)}}
                 end
                 @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:new_project_id]} if params[:new_project_id]
                 @target_project ||= @project
                 @trackers = @target_project.trackers
                 if request.post?
                   new_tracker = params[:new_tracker_id].blank? ? nil : @target_project.trackers.find_by_id(params[:new_tracker_id])
                   unsaved_issue_ids = []
                   @issues.each do |issue|
                     issue.init_journal(User.current)
                     unsaved_issue_ids << issue.id unless issue.move_to(@target_project, new_tracker, params[:copy_options])
                   end
                   if unsaved_issue_ids.empty?
                     flash[:notice] = l(:notice_successful_update) unless @issues.empty?
                   else
                     flash[:error] = l(:notice_failed_to_save_issues, :count => unsaved_issue_ids.size,
                                                                      :total => @issues.size,
                                                                      :ids => '#' + unsaved_issue_ids.join(', #'))
                   end
                   redirect_to :controller => 'issues', :action => 'index', :project_id => @project
                   return
                 end
                 render :layout => false if request.xhr?
               end
               def destroy
                 @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
                 if @hours > 0
                   case params[:todo]
                   when 'destroy'
                     # nothing to do
                   when 'nullify'
                     TimeEntry.update_all('issue_id = NULL', ['issue_id IN (?)', @issues])
                   when 'reassign'
                     reassign_to = @project.issues.find_by_id(params[:reassign_to_id])
                     if reassign_to.nil?
                       flash.now[:error] = l(:error_issue_not_found_in_project)
                       return
                     else
                       TimeEntry.update_all("issue_id = #{reassign_to.id}", ['issue_id IN (?)', @issues])
                     end
                   else
                     # display the destroy form
                     return
                   end
                 end
                 @issues.each(&:destroy)
                 redirect_to :action => 'index', :project_id => @project
               end
               def gantt
                 @gantt = Redmine::Helpers::Gantt.new(params)
                 retrieve_query
                 if @query.valid?
                   events = []
                   # Issues that have start and due dates
                   events += Issue.find(:all,
                                        :order => "start_date, due_date",
                                        :include => [:tracker, :status, :assigned_to, :priority, :project],
                                        :conditions => ["(#{@query.statement}) AND (((start_date>=? and start_date<=?) or (due_date>=? and due_date<=?) or (start_date<? and due_date>?)) and start_date is not null and due_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]
                                        )
                   # Issues that don't have a due date but that are assigned to a version with a date
                   events += Issue.find(:all,
                                        :order => "start_date, effective_date",
                                        :include => [:tracker, :status, :assigned_to, :priority, :project, :fixed_version],
                                        :conditions => ["(#{@query.statement}) AND (((start_date>=? and start_date<=?) or (effective_date>=? and effective_date<=?) or (start_date<? and effective_date>?)) and start_date is not null and due_date is null and effective_date is not null)", @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to, @gantt.date_from, @gantt.date_to]
                                        )
                   # Versions
                   events += Version.find(:all, :include => :project,
                                                :conditions => ["(#{@query.project_statement}) AND effective_date BETWEEN ? AND ?", @gantt.date_from, @gantt.date_to])
                   @gantt.events = events
                 end
                 basename = (@project ? "#{@project.identifier}-" : '') + 'gantt'
                 respond_to do |format|
                   format.html { render :template => "issues/gantt.rhtml", :layout => !request.xhr? }
                   format.png  { send_data(@gantt.to_image, :disposition => 'inline', :type => 'image/png', :filename => "#{basename}.png") } if @gantt.respond_to?('to_image')
                   format.pdf  { send_data(gantt_to_pdf(@gantt, @project), :type => 'application/pdf', :filename => "#{basename}.pdf") }
                 end
               end
               def calendar
                 if params[:year] and params[:year].to_i > 1900
                   @year = params[:year].to_i
                   if params[:month] and params[:month].to_i > 0 and params[:month].to_i < 13
                     @month = params[:month].to_i
                   end
                 end
                 @year ||= Date.today.year
                 @month ||= Date.today.month
                 @calendar = Redmine::Helpers::Calendar.new(Date.civil(@year, @month, 1), current_language, :month)
                 retrieve_query
                 if @query.valid?
                   events = []
                   events += Issue.find(:all,
                                        :include => [:tracker, :status, :assigned_to, :priority, :project],
                                        :conditions => ["(#{@query.statement}) AND ((start_date BETWEEN ? AND ?) OR (due_date BETWEEN ? AND ?))", @calendar.startdt, @calendar.enddt, @calendar.startdt, @calendar.enddt]
                                        )
                   events += Version.find(:all, :include => :project,
                                                :conditions => ["(#{@query.project_statement}) AND effective_date BETWEEN ? AND ?", @calendar.startdt, @calendar.enddt])
                   @calendar.events = events
                 end
                 render :layout => false if request.xhr?
               end
               def context_menu
                 @issues = Issue.find_all_by_id(params[:ids], :include => :project)
                 if (@issues.size == 1)
                   @issue = @issues.first
                   @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 end
                 projects = @issues.collect(&:project).compact.uniq
                 @project = projects.first if projects.size == 1
                 @can = {:edit => (@project && User.current.allowed_to?(:edit_issues, @project)),
                         :log_time => (@project && User.current.allowed_to?(:log_time, @project)),
                         :update => (@project && (User.current.allowed_to?(:edit_issues, @project) || (User.current.allowed_to?(:change_status, @project) && @allowed_statuses && !@allowed_statuses.empty?))),
                         :move => (@project && User.current.allowed_to?(:move_issues, @project)),
                         :copy => (@issue && @project.trackers.include?(@issue.tracker) && User.current.allowed_to?(:add_issues, @project)),
                         :delete => (@project && User.current.allowed_to?(:delete_issues, @project))
                         }
                 if @project
                   @assignables = @project.assignable_users
                   @assignables << @issue.assigned_to if @issue && @issue.assigned_to && !@assignables.include?(@issue.assigned_to)
                 end
                 @priorities = IssuePriority.all.reverse
                 @statuses = IssueStatus.find(:all, :order => 'position')
                 @back = request.env['HTTP_REFERER']
                 render :layout => false
               end
               def update_form
                 @issue = Issue.new(params[:issue])
                 render :action => :new, :layout => false
               end
               def preview
                 @issue = @project.issues.find_by_id(params[:id]) unless params[:id].blank?
                 @attachements = @issue.attachments if @issue
                 @text = params[:notes] || (params[:issue] ? params[:issue][:description] : nil)
                 render :partial => 'common/preview'
               end
             private
               def find_issue
                 @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                 @project = @issue.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Filter for bulk operations
               def find_issues
                 @issues = Issue.find_all_by_id(params[:id] || params[:ids])
                 raise ActiveRecord::RecordNotFound if @issues.empty?
                 projects = @issues.collect(&:project).compact.uniq
                 if projects.size == 1
                   @project = projects.first
                 else
                   # TODO: let users bulk edit/move/destroy issues from different projects
                   render_error 'Can not bulk edit/move/destroy issues from different projects' and return false
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_project
                 @project = Project.find(params[:project_id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 @project = Project.find(params[:project_id]) unless params[:project_id].blank?
                 allowed = User.current.allowed_to?({:controller => params[:controller], :action => params[:action]}, @project, :global => true)
                 allowed ? true : deny_access
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Retrieve query from session or build a new query
               def retrieve_query
                 if !params[:query_id].blank?
                   cond = "project_id IS NULL"
                   cond << " OR project_id = #{@project.id}" if @project
                   @query = Query.find(params[:query_id], :conditions => cond)
                   @query.project = @project
                   session[:query] = {:id => @query.id, :project_id => @query.project_id}
                   sort_clear
                 else
                   if params[:set_filter] || session[:query].nil? || session[:query][:project_id] != (@project ? @project.id : nil)
                     # Give it a name, required to be valid
                     @query = Query.new(:name => "_")
                     @query.project = @project
                     if params[:fields] and params[:fields].is_a? Array
                       params[:fields].each do |field|
                         @query.add_filter(field, params[:operators][field], params[:values][field])
                       end
                     else
                       @query.available_filters.keys.each do |field|
                         @query.add_short_filter(field, params[field]) if params[field]
                       end
                     end
                     @query.group_by = params[:group_by]
                     session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by}
                   else
                     @query = Query.find_by_id(session[:query][:id]) if session[:query][:id]
                     @query ||= Query.new(:name => "_", :project => @project, :filters => session[:query][:filters], :group_by => session[:query][:group_by])
                     @query.project = @project
                   end
                 end
               end
             end

app/controllers/timelog_controller.rb +2 -2

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class TimelogController < ApplicationController
               menu_item :issues
               before_filter :find_project, :authorize, :only => [:edit, :destroy]
               before_filter :find_optional_project, :only => [:report, :details]
               verify :method => :post, :only => :destroy, :redirect_to => { :action => :details }
               helper :sort
               include SortHelper
               helper :issues
               include TimelogHelper
               helper :custom_fields
               include CustomFieldsHelper
               def report
                 @available_criterias = { 'project' => {:sql => "#{TimeEntry.table_name}.project_id",
                                                       :klass => Project,
                                                       :label => :label_project},
                                          'version' => {:sql => "#{Issue.table_name}.fixed_version_id",
                                                       :klass => Version,
                                                       :label => :label_version},
                                          'category' => {:sql => "#{Issue.table_name}.category_id",
                                                         :klass => IssueCategory,
                                                         :label => :field_category},
                                          'member' => {:sql => "#{TimeEntry.table_name}.user_id",
                                                      :klass => User,
                                                      :label => :label_member},
                                          'tracker' => {:sql => "#{Issue.table_name}.tracker_id",
                                                       :klass => Tracker,
                                                       :label => :label_tracker},
                                          'activity' => {:sql => "#{TimeEntry.table_name}.activity_id",
                                                        :klass => TimeEntryActivity,
                                                        :label => :label_activity},
                                          'issue' => {:sql => "#{TimeEntry.table_name}.issue_id",
                                                      :klass => Issue,
                                                      :label => :label_issue}
                                        }
                 # Add list and boolean custom fields as available criterias
                 custom_fields = (@project.nil? ? IssueCustomField.for_all : @project.all_issue_custom_fields)
                 custom_fields.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                   @available_criterias["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Issue' AND c.customized_id = #{Issue.table_name}.id)",
                                                          :format => cf.field_format,
                                                          :label => cf.name}
                 end if @project
                 # Add list and boolean time entry custom fields
                 TimeEntryCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                   @available_criterias["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'TimeEntry' AND c.customized_id = #{TimeEntry.table_name}.id)",
                                                          :format => cf.field_format,
                                                          :label => cf.name}
                 end
                 # Add list and boolean time entry activity custom fields
                 TimeEntryActivityCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                   @available_criterias["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Enumeration' AND c.customized_id = #{TimeEntry.table_name}.activity_id)",
                                                          :format => cf.field_format,
                                                          :label => cf.name}
                 end
                 @criterias = params[:criterias] || []
                 @criterias = @criterias.select{|criteria| @available_criterias.has_key? criteria}
                 @criterias.uniq!
                 @criterias = @criterias[0,3]
                 @columns = (params[:columns] && %w(year month week day).include?(params[:columns])) ? params[:columns] : 'month'
                 retrieve_date_range
                 unless @criterias.empty?
                   sql_select = @criterias.collect{|criteria| @available_criterias[criteria][:sql] + " AS " + criteria}.join(', ')
                   sql_group_by = @criterias.collect{|criteria| @available_criterias[criteria][:sql]}.join(', ')
                   sql_condition = ''
                   if @project.nil?
                     sql_condition = Project.allowed_to_condition(User.current, :view_time_entries)
                   elsif @issue.nil?
                     sql_condition = @project.project_condition(Setting.display_subprojects_issues?)
                   else
                     sql_condition = "#{TimeEntry.table_name}.issue_id = #{@issue.id}"
                   end
                   sql = "SELECT #{sql_select}, tyear, tmonth, tweek, spent_on, SUM(hours) AS hours"
                   sql << " FROM #{TimeEntry.table_name}"
                   sql << " LEFT JOIN #{Issue.table_name} ON #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id"
                   sql << " LEFT JOIN #{Project.table_name} ON #{TimeEntry.table_name}.project_id = #{Project.table_name}.id"
                   sql << " WHERE"
                   sql << " (%s) AND" % sql_condition
                   sql << " (spent_on BETWEEN '%s' AND '%s')" % [ActiveRecord::Base.connection.quoted_date(@from.to_time), ActiveRecord::Base.connection.quoted_date(@to.to_time)]
                   sql << " GROUP BY #{sql_group_by}, tyear, tmonth, tweek, spent_on"
                   @hours = ActiveRecord::Base.connection.select_all(sql)
                   @hours.each do |row|
                     case @columns
                     when 'year'
                       row['year'] = row['tyear']
                     when 'month'
                       row['month'] = "#{row['tyear']}-#{row['tmonth']}"
                     when 'week'
                       row['week'] = "#{row['tyear']}-#{row['tweek']}"
                     when 'day'
                       row['day'] = "#{row['spent_on']}"
                     end
                   end
                   @total_hours = @hours.inject(0) {|s,k| s = s + k['hours'].to_f}
                   @periods = []
                   # Date#at_beginning_of_ not supported in Rails 1.2.x
                   date_from = @from.to_time
                   # 100 columns max
                   while date_from <= @to.to_time && @periods.length < 100
                     case @columns
                     when 'year'
                       @periods << "#{date_from.year}"
                       date_from = (date_from + 1.year).at_beginning_of_year
                     when 'month'
                       @periods << "#{date_from.year}-#{date_from.month}"
                       date_from = (date_from + 1.month).at_beginning_of_month
                     when 'week'
                       @periods << "#{date_from.year}-#{date_from.to_date.cweek}"
                       date_from = (date_from + 7.day).at_beginning_of_week
                     when 'day'
                       @periods << "#{date_from.to_date}"
                       date_from = date_from + 1.day
                     end
                   end
                 end
                 respond_to do |format|
                   format.html { render :layout => !request.xhr? }
-                  format.csv  { send_data(report_to_csv(@criterias, @periods, @hours).read, :type => 'text/csv; header=present', :filename => 'timelog.csv') }
+                  format.csv  { send_data(report_to_csv(@criterias, @periods, @hours), :type => 'text/csv; header=present', :filename => 'timelog.csv') }
                 end
               end
               def details
                 sort_init 'spent_on', 'desc'
                 sort_update 'spent_on' => 'spent_on',
                             'user' => 'user_id',
                             'activity' => 'activity_id',
                             'project' => "#{Project.table_name}.name",
                             'issue' => 'issue_id',
                             'hours' => 'hours'
                 cond = ARCondition.new
                 if @project.nil?
                   cond << Project.allowed_to_condition(User.current, :view_time_entries)
                 elsif @issue.nil?
                   cond << @project.project_condition(Setting.display_subprojects_issues?)
                 else
                   cond << ["#{TimeEntry.table_name}.issue_id = ?", @issue.id]
                 end
                 retrieve_date_range
                 cond << ['spent_on BETWEEN ? AND ?', @from, @to]
                 TimeEntry.visible_by(User.current) do
                   respond_to do |format|
                     format.html {
                       # Paginate results
                       @entry_count = TimeEntry.count(:include => :project, :conditions => cond.conditions)
                       @entry_pages = Paginator.new self, @entry_count, per_page_option, params['page']
                       @entries = TimeEntry.find(:all,
                                                 :include => [:project, :activity, :user, {:issue => :tracker}],
                                                 :conditions => cond.conditions,
                                                 :order => sort_clause,
                                                 :limit  =>  @entry_pages.items_per_page,
                                                 :offset =>  @entry_pages.current.offset)
                       @total_hours = TimeEntry.sum(:hours, :include => :project, :conditions => cond.conditions).to_f
                       render :layout => !request.xhr?
                     }
                     format.atom {
                       entries = TimeEntry.find(:all,
                                                :include => [:project, :activity, :user, {:issue => :tracker}],
                                                :conditions => cond.conditions,
                                                :order => "#{TimeEntry.table_name}.created_on DESC",
                                                :limit => Setting.feeds_limit.to_i)
                       render_feed(entries, :title => l(:label_spent_time))
                     }
                     format.csv {
                       # Export all entries
                       @entries = TimeEntry.find(:all,
                                                 :include => [:project, :activity, :user, {:issue => [:tracker, :assigned_to, :priority]}],
                                                 :conditions => cond.conditions,
                                                 :order => sort_clause)
-                      send_data(entries_to_csv(@entries).read, :type => 'text/csv; header=present', :filename => 'timelog.csv')
+                      send_data(entries_to_csv(@entries), :type => 'text/csv; header=present', :filename => 'timelog.csv')
                     }
                   end
                 end
               end
               def edit
                 render_403 and return if @time_entry && !@time_entry.editable_by?(User.current)
                 @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
                 @time_entry.attributes = params[:time_entry]
                 call_hook(:controller_timelog_edit_before_save, { :params => params, :time_entry => @time_entry })
                 if request.post? and @time_entry.save
                   flash[:notice] = l(:notice_successful_update)
                   redirect_back_or_default :action => 'details', :project_id => @time_entry.project
                   return
                 end
               end
               def destroy
                 render_404 and return unless @time_entry
                 render_403 and return unless @time_entry.editable_by?(User.current)
                 @time_entry.destroy
                 flash[:notice] = l(:notice_successful_delete)
                 redirect_to :back
               rescue ::ActionController::RedirectBackError
                 redirect_to :action => 'details', :project_id => @time_entry.project
               end
             private
               def find_project
                 if params[:id]
                   @time_entry = TimeEntry.find(params[:id])
                   @project = @time_entry.project
                 elsif params[:issue_id]
                   @issue = Issue.find(params[:issue_id])
                   @project = @issue.project
                 elsif params[:project_id]
                   @project = Project.find(params[:project_id])
                 else
                   render_404
                   return false
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 if !params[:issue_id].blank?
                   @issue = Issue.find(params[:issue_id])
                   @project = @issue.project
                 elsif !params[:project_id].blank?
                   @project = Project.find(params[:project_id])
                 end
                 deny_access unless User.current.allowed_to?(:view_time_entries, @project, :global => true)
               end
               # Retrieves the date range based on predefined ranges or specific from/to param dates
               def retrieve_date_range
                 @free_period = false
                 @from, @to = nil, nil
                 if params[:period_type] == '1' || (params[:period_type].nil? && !params[:period].nil?)
                   case params[:period].to_s
                   when 'today'
                     @from = @to = Date.today
                   when 'yesterday'
                     @from = @to = Date.today - 1
                   when 'current_week'
                     @from = Date.today - (Date.today.cwday - 1)%7
                     @to = @from + 6
                   when 'last_week'
                     @from = Date.today - 7 - (Date.today.cwday - 1)%7
                     @to = @from + 6
                   when '7_days'
                     @from = Date.today - 7
                     @to = Date.today
                   when 'current_month'
                     @from = Date.civil(Date.today.year, Date.today.month, 1)
                     @to = (@from >> 1) - 1
                   when 'last_month'
                     @from = Date.civil(Date.today.year, Date.today.month, 1) << 1
                     @to = (@from >> 1) - 1
                   when '30_days'
                     @from = Date.today - 30
                     @to = Date.today
                   when 'current_year'
                     @from = Date.civil(Date.today.year, 1, 1)
                     @to = Date.civil(Date.today.year, 12, 31)
                   end
                 elsif params[:period_type] == '2' || (params[:period_type].nil? && (!params[:from].nil? || !params[:to].nil?))
                   begin; @from = params[:from].to_s.to_date unless params[:from].blank?; rescue; end
                   begin; @to = params[:to].to_s.to_date unless params[:to].blank?; rescue; end
                   @free_period = true
                 else
                   # default
                 end
                 @from, @to = @to, @from if @from && @to && @from > @to
                 @from ||= (TimeEntry.minimum(:spent_on, :include => :project, :conditions => Project.allowed_to_condition(User.current, :view_time_entries)) || Date.today) - 1
                 @to   ||= (TimeEntry.maximum(:spent_on, :include => :project, :conditions => Project.allowed_to_condition(User.current, :view_time_entries)) || Date.today)
               end
             end

app/helpers/issues_helper.rb +1 -5

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-            require 'csv'
             module IssuesHelper
               include ApplicationHelper
               def render_issue_tooltip(issue)
                 @cached_label_start_date ||= l(:field_start_date)
                 @cached_label_due_date ||= l(:field_due_date)
                 @cached_label_assigned_to ||= l(:field_assigned_to)
                 @cached_label_priority ||= l(:field_priority)
                 link_to_issue(issue) + ": #{h(issue.subject)}<br /><br />" +
                   "<strong>#{@cached_label_start_date}</strong>: #{format_date(issue.start_date)}<br />" +
                   "<strong>#{@cached_label_due_date}</strong>: #{format_date(issue.due_date)}<br />" +
                   "<strong>#{@cached_label_assigned_to}</strong>: #{issue.assigned_to}<br />" +
                   "<strong>#{@cached_label_priority}</strong>: #{issue.priority.name}"
               end
               def render_custom_fields_rows(issue)
                 return if issue.custom_field_values.empty?
                 ordered_values = []
                 half = (issue.custom_field_values.size / 2.0).ceil
                 half.times do |i|
                   ordered_values << issue.custom_field_values[i]
                   ordered_values << issue.custom_field_values[i + half]
                 end
                 s = "<tr>\n"
                 n = 0
                 ordered_values.compact.each do |value|
                   s << "</tr>\n<tr>\n" if n > 0 && (n % 2) == 0
                   s << "\t<th>#{ h(value.custom_field.name) }:</th><td>#{ simple_format_without_paragraph(h(show_value(value))) }</td>\n"
                   n += 1
                 end
                 s << "</tr>\n"
                 s
               end
               def sidebar_queries
                 unless @sidebar_queries
                   # User can see public queries and his own queries
                   visible = ARCondition.new(["is_public = ? OR user_id = ?", true, (User.current.logged? ? User.current.id : 0)])
                   # Project specific queries and global queries
                   visible << (@project.nil? ? ["project_id IS NULL"] : ["project_id IS NULL OR project_id = ?", @project.id])
                   @sidebar_queries = Query.find(:all,
                                                 :select => 'id, name',
                                                 :order => "name ASC",
                                                 :conditions => visible.conditions)
                 end
                 @sidebar_queries
               end
               def show_detail(detail, no_html=false)
                 case detail.property
                 when 'attr'
                   label = l(("field_" + detail.prop_key.to_s.gsub(/\_id$/, "")).to_sym)
                   case detail.prop_key
                   when 'due_date', 'start_date'
                     value = format_date(detail.value.to_date) if detail.value
                     old_value = format_date(detail.old_value.to_date) if detail.old_value
                   when 'project_id'
                     p = Project.find_by_id(detail.value) and value = p.name if detail.value
                     p = Project.find_by_id(detail.old_value) and old_value = p.name if detail.old_value
                   when 'status_id'
                     s = IssueStatus.find_by_id(detail.value) and value = s.name if detail.value
                     s = IssueStatus.find_by_id(detail.old_value) and old_value = s.name if detail.old_value
                   when 'tracker_id'
                     t = Tracker.find_by_id(detail.value) and value = t.name if detail.value
                     t = Tracker.find_by_id(detail.old_value) and old_value = t.name if detail.old_value
                   when 'assigned_to_id'
                     u = User.find_by_id(detail.value) and value = u.name if detail.value
                     u = User.find_by_id(detail.old_value) and old_value = u.name if detail.old_value
                   when 'priority_id'
                     e = IssuePriority.find_by_id(detail.value) and value = e.name if detail.value
                     e = IssuePriority.find_by_id(detail.old_value) and old_value = e.name if detail.old_value
                   when 'category_id'
                     c = IssueCategory.find_by_id(detail.value) and value = c.name if detail.value
                     c = IssueCategory.find_by_id(detail.old_value) and old_value = c.name if detail.old_value
                   when 'fixed_version_id'
                     v = Version.find_by_id(detail.value) and value = v.name if detail.value
                     v = Version.find_by_id(detail.old_value) and old_value = v.name if detail.old_value
                   when 'estimated_hours'
                     value = "%0.02f" % detail.value.to_f unless detail.value.blank?
                     old_value = "%0.02f" % detail.old_value.to_f unless detail.old_value.blank?
                   end
                 when 'cf'
                   custom_field = CustomField.find_by_id(detail.prop_key)
                   if custom_field
                     label = custom_field.name
                     value = format_value(detail.value, custom_field.field_format) if detail.value
                     old_value = format_value(detail.old_value, custom_field.field_format) if detail.old_value
                   end
                 when 'attachment'
                   label = l(:label_attachment)
                 end
                 call_hook(:helper_issues_show_detail_after_setting, {:detail => detail, :label => label, :value => value, :old_value => old_value })
                 label ||= detail.prop_key
                 value ||= detail.value
                 old_value ||= detail.old_value
                 unless no_html
                   label = content_tag('strong', label)
                   old_value = content_tag("i", h(old_value)) if detail.old_value
                   old_value = content_tag("strike", old_value) if detail.old_value and (!detail.value or detail.value.empty?)
                   if detail.property == 'attachment' && !value.blank? && a = Attachment.find_by_id(detail.prop_key)
                     # Link to the attachment if it has not been removed
                     value = link_to_attachment(a)
                   else
                     value = content_tag("i", h(value)) if value
                   end
                 end
                 if !detail.value.blank?
                   case detail.property
                   when 'attr', 'cf'
                     if !detail.old_value.blank?
                       l(:text_journal_changed, :label => label, :old => old_value, :new => value)
                     else
                       l(:text_journal_set_to, :label => label, :value => value)
                     end
                   when 'attachment'
                     l(:text_journal_added, :label => label, :value => value)
                   end
                 else
                   l(:text_journal_deleted, :label => label, :old => old_value)
                 end
               end
               def issues_to_csv(issues, project = nil)
                 ic = Iconv.new(l(:general_csv_encoding), 'UTF-8')
                 decimal_separator = l(:general_csv_decimal_separator)
-                export = StringIO.new
+                export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
-                CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                   # csv header fields
                   headers = [ "#",
                               l(:field_status),
                               l(:field_project),
                               l(:field_tracker),
                               l(:field_priority),
                               l(:field_subject),
                               l(:field_assigned_to),
                               l(:field_category),
                               l(:field_fixed_version),
                               l(:field_author),
                               l(:field_start_date),
                               l(:field_due_date),
                               l(:field_done_ratio),
                               l(:field_estimated_hours),
                               l(:field_created_on),
                               l(:field_updated_on)
                               ]
                   # Export project custom fields if project is given
                   # otherwise export custom fields marked as "For all projects"
                   custom_fields = project.nil? ? IssueCustomField.for_all : project.all_issue_custom_fields
                   custom_fields.each {|f| headers << f.name}
                   # Description in the last column
                   headers << l(:field_description)
                   csv << headers.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                   # csv lines
                   issues.each do |issue|
                     fields = [issue.id,
                               issue.status.name,
                               issue.project.name,
                               issue.tracker.name,
                               issue.priority.name,
                               issue.subject,
                               issue.assigned_to,
                               issue.category,
                               issue.fixed_version,
                               issue.author.name,
                               format_date(issue.start_date),
                               format_date(issue.due_date),
                               issue.done_ratio,
                               issue.estimated_hours.to_s.gsub('.', decimal_separator),
                               format_time(issue.created_on),
                               format_time(issue.updated_on)
                               ]
                     custom_fields.each {|f| fields << show_value(issue.custom_value_for(f)) }
                     fields << issue.description
                     csv << fields.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                   end
                 end
-                export.rewind
                 export
               end
             end

app/helpers/timelog_helper.rb +2 -6

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module TimelogHelper
               include ApplicationHelper
               def render_timelog_breadcrumb
                 links = []
                 links << link_to(l(:label_project_all), {:project_id => nil, :issue_id => nil})
                 links << link_to(h(@project), {:project_id => @project, :issue_id => nil}) if @project
                 links << link_to_issue(@issue) if @issue
                 breadcrumb links
               end
               # Returns a collection of activities for a select field.  time_entry
               # is optional and will be used to check if the selected TimeEntryActivity
               # is active.
               def activity_collection_for_select_options(time_entry=nil, project=nil)
                 project ||= @project
                 if project.nil?
                   activities = TimeEntryActivity.active
                 else
                   activities = project.activities
                 end
                 collection = []
                 if time_entry && time_entry.activity && !time_entry.activity.active?
                   collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ]
                 else
                   collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)
                 end
                 activities.each { |a| collection << [a.name, a.id] }
                 collection
               end
               def select_hours(data, criteria, value)
               	if value.to_s.empty?
               		data.select {|row| row[criteria].blank? }
                 else
                 	data.select {|row| row[criteria] == value}
                 end
               end
               def sum_hours(data)
                 sum = 0
                 data.each do |row|
                   sum += row['hours'].to_f
                 end
                 sum
               end
               def options_for_period_select(value)
                 options_for_select([[l(:label_all_time), 'all'],
                                     [l(:label_today), 'today'],
                                     [l(:label_yesterday), 'yesterday'],
                                     [l(:label_this_week), 'current_week'],
                                     [l(:label_last_week), 'last_week'],
                                     [l(:label_last_n_days, 7), '7_days'],
                                     [l(:label_this_month), 'current_month'],
                                     [l(:label_last_month), 'last_month'],
                                     [l(:label_last_n_days, 30), '30_days'],
                                     [l(:label_this_year), 'current_year']],
                                     value)
               end
               def entries_to_csv(entries)
                 ic = Iconv.new(l(:general_csv_encoding), 'UTF-8')
                 decimal_separator = l(:general_csv_decimal_separator)
                 custom_fields = TimeEntryCustomField.find(:all)
-                export = StringIO.new
+                export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
-                CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                   # csv header fields
                   headers = [l(:field_spent_on),
                              l(:field_user),
                              l(:field_activity),
                              l(:field_project),
                              l(:field_issue),
                              l(:field_tracker),
                              l(:field_subject),
                              l(:field_hours),
                              l(:field_comments)
                              ]
                   # Export custom fields
                   headers += custom_fields.collect(&:name)
                   csv << headers.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                   # csv lines
                   entries.each do |entry|
                     fields = [format_date(entry.spent_on),
                               entry.user,
                               entry.activity,
                               entry.project,
                               (entry.issue ? entry.issue.id : nil),
                               (entry.issue ? entry.issue.tracker : nil),
                               (entry.issue ? entry.issue.subject : nil),
                               entry.hours.to_s.gsub('.', decimal_separator),
                               entry.comments
                               ]
                     fields += custom_fields.collect {|f| show_value(entry.custom_value_for(f)) }
                     csv << fields.collect {|c| begin; ic.iconv(c.to_s); rescue; c.to_s; end }
                   end
                 end
-                export.rewind
                 export
               end
               def format_criteria_value(criteria, value)
                 value.blank? ? l(:label_none) : ((k = @available_criterias[criteria][:klass]) ? k.find_by_id(value.to_i) : format_value(value, @available_criterias[criteria][:format]))
               end
               def report_to_csv(criterias, periods, hours)
-                export = StringIO.new
+                export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
-                CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
                   # Column headers
                   headers = criterias.collect {|criteria| l(@available_criterias[criteria][:label]) }
                   headers += periods
                   headers << l(:label_total)
                   csv << headers.collect {|c| to_utf8(c) }
                   # Content
                   report_criteria_to_csv(csv, criterias, periods, hours)
                   # Total row
                   row = [ l(:label_total) ] + [''] * (criterias.size - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours, @columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? "%.2f" % sum : '')
                   end
                   row << "%.2f" %total
                   csv << row
                 end
-                export.rewind
                 export
               end
               def report_criteria_to_csv(csv, criterias, periods, hours, level=0)
                 hours.collect {|h| h[criterias[level]].to_s}.uniq.each do |value|
                   hours_for_value = select_hours(hours, criterias[level], value)
                   next if hours_for_value.empty?
                   row = [''] * level
                   row << to_utf8(format_criteria_value(criterias[level], value))
                   row += [''] * (criterias.length - level - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours_for_value, @columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? "%.2f" % sum : '')
                   end
                   row << "%.2f" %total
                   csv << row
                   if criterias.length > level + 1
                     report_criteria_to_csv(csv, criterias, periods, hours_for_value, level + 1)
                   end
                 end
               end
               def to_utf8(s)
                 @ic ||= Iconv.new(l(:general_csv_encoding), 'UTF-8')
                 begin; @ic.iconv(s.to_s); rescue; s.to_s; end
               end
             end

lib/redmine.rb +7 0

             require 'redmine/access_control'
             require 'redmine/menu_manager'
             require 'redmine/activity'
             require 'redmine/mime_type'
             require 'redmine/core_ext'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             require 'redmine/wiki_formatting'
             begin
               require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
+            if RUBY_VERSION < '1.9'
+              require 'faster_csv'
+            else
+              require 'csv'
+              FCSV = CSV
+            end
             REDMINE_SUPPORTED_SCM = %w( Subversion Darcs Mercurial Cvs Bazaar Git Filesystem )
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show, :activity]}, :public => true
               map.permission :search_project, {:search => :index}, :public => true
               map.permission :add_project, {:projects => :add}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit]}, :require => :member
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy, :autocomplete_for_member]}, :require => :member
               map.permission :manage_versions, {:projects => [:settings, :add_version], :versions => [:edit, :destroy]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => [:settings, :add_issue_category], :issue_categories => [:edit, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:projects => [:changelog, :roadmap],
                                               :issues => [:index, :changes, :show, :context_menu],
                                               :versions => [:show, :status_by],
                                               :queries => :index,
                                               :reports => :issue_report}, :public => true
                 map.permission :add_issues, {:issues => :new}
                 map.permission :edit_issues, {:issues => [:edit, :reply, :bulk_edit]}
                 map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy]}
                 map.permission :add_issue_notes, {:issues => [:edit, :reply]}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :move_issues, {:issues => :move}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :edit, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :edit, :destroy]}, :require => :loggedin
                 # Gantt & calendar
                 map.permission :view_gantt, :issues => :gantt
                 map.permission :view_calendar, :issues => :calendar
                 # Watchers
                 map.permission :view_issue_watchers, {}
                 map.permission :add_issue_watchers, {:watchers => :new}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => :edit}, :require => :loggedin
                 map.permission :view_time_entries, :timelog => [:details, :report]
                 map.permission :edit_time_entries, {:timelog => [:edit, :destroy]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :destroy]}, :require => :loggedin
                 map.permission :manage_project_activities, {:projects => [:save_activities, :reset_activities]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :edit, :destroy, :destroy_comment]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true
                 map.permission :comment_news, {:news => :add_comment}
               end
               map.project_module :documents do |map|
                 map.permission :manage_documents, {:documents => [:new, :edit, :destroy, :add_attachment]}, :require => :loggedin
                 map.permission :view_documents, :documents => [:index, :show, :download]
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:projects => :add_file}, :require => :loggedin
                 map.permission :view_files, :projects => :list_files, :versions => :download
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => :destroy}, :require => :member
                 map.permission :view_wiki_pages, :wiki => [:index, :special]
                 map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:edit, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, :repositories => [:show, :browse, :entry, :annotate, :changes, :diff, :stats, :graph]
                 map.permission :view_changesets, :repositories => [:show, :revisions, :revision]
                 map.permission :commit_access, {}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :edit, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, { :controller => 'account', :action => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'projects', :action => 'activity' }
               menu.push :roadmap, { :controller => 'projects', :action => 'roadmap' },
                           :if => Proc.new { |p| p.versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'index', :page => nil },
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'projects', :action => 'list_files' }, :caption => :label_attachment_plural
               menu.push :repository, { :controller => 'repositories', :action => 'show' },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
               activity.register :time_entries, :default => false
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
             end

test/functional/issues_controller_test.rb +3 0

             # Redmine - project management software
             # Copyright (C) 2006-2008  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             require 'issues_controller'
             # Re-raise errors caught by the controller.
             class IssuesController; def rescue_action(e) raise e end; end
             class IssuesControllerTest < ActionController::TestCase
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issues,
                        :issue_statuses,
                        :versions,
                        :trackers,
                        :projects_trackers,
                        :issue_categories,
                        :enabled_modules,
                        :enumerations,
                        :attachments,
                        :workflows,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_trackers,
                        :time_entries,
                        :journals,
                        :journal_details,
                        :queries
               def setup
                 @controller = IssuesController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_index_routing
                 assert_routing(
                   {:method => :get, :path => '/issues'},
                   :controller => 'issues', :action => 'index'
                 )
               end
               def test_index
                 Setting.default_language = 'en'
                 get :index
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:project)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 # private projects hidden
                 assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
                 assert_no_tag :tag => 'a', :content => /Issue on project 2/
                 # project column
                 assert_tag :tag => 'th', :content => /Project/
               end
               def test_index_should_not_list_issues_when_module_disabled
                 EnabledModule.delete_all("name = 'issue_tracking' AND project_id = 1")
                 get :index
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:project)
                 assert_no_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_with_project_routing
                 assert_routing(
                   {:method => :get, :path => '/projects/23/issues'},
                   :controller => 'issues', :action => 'index', :project_id => '23'
                 )
               end
               def test_index_should_not_list_issues_when_module_disabled
                 EnabledModule.delete_all("name = 'issue_tracking' AND project_id = 1")
                 get :index
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:project)
                 assert_no_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_with_project_routing
                 assert_routing(
                   {:method => :get, :path => 'projects/23/issues'},
                   :controller => 'issues', :action => 'index', :project_id => '23'
                 )
               end
               def test_index_with_project
                 Setting.display_subprojects_issues = 0
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_no_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_with_project_and_subprojects
                 Setting.display_subprojects_issues = 1
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
               end
               def test_index_with_project_and_subprojects_should_show_private_subprojects
                 @request.session[:user_id] = 2
                 Setting.display_subprojects_issues = 1
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 assert_tag :tag => 'a', :content => /Issue of a private subproject/
               end
               def test_index_with_project_routing_formatted
                 assert_routing(
                   {:method => :get, :path => 'projects/23/issues.pdf'},
                   :controller => 'issues', :action => 'index', :project_id => '23', :format => 'pdf'
                 )
                 assert_routing(
                   {:method => :get, :path => 'projects/23/issues.atom'},
                   :controller => 'issues', :action => 'index', :project_id => '23', :format => 'atom'
                 )
               end
               def test_index_with_project_and_filter
                 get :index, :project_id => 1, :set_filter => 1
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
               end
               def test_index_with_query
                 get :index, :project_id => 1, :query_id => 5
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:issue_count_by_group)
               end
               def test_index_with_grouped_query
                 get :index, :project_id => 1, :query_id => 6
                 assert_response :success
                 assert_template 'index.rhtml'
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
               end
               def test_index_csv_with_project
+                Setting.default_language = 'en'
                 get :index, :format => 'csv'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
+                assert @response.body.starts_with?("#,")
                 get :index, :project_id => 1, :format => 'csv'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
               end
               def test_index_formatted
                 assert_routing(
                   {:method => :get, :path => 'issues.pdf'},
                   :controller => 'issues', :action => 'index', :format => 'pdf'
                 )
                 assert_routing(
                   {:method => :get, :path => 'issues.atom'},
                   :controller => 'issues', :action => 'index', :format => 'atom'
                 )
               end
               def test_index_pdf
                 get :index, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'application/pdf', @response.content_type
                 get :index, :project_id => 1, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'application/pdf', @response.content_type
                 get :index, :project_id => 1, :query_id => 6, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'application/pdf', @response.content_type
               end
               def test_index_sort
                 get :index, :sort => 'tracker,id:desc'
                 assert_response :success
                 sort_params = @request.session['issues_index_sort']
                 assert sort_params.is_a?(String)
                 assert_equal 'tracker,id:desc', sort_params
                 issues = assigns(:issues)
                 assert_not_nil issues
                 assert !issues.empty?
                 assert_equal issues.sort {|a,b| a.tracker == b.tracker ? b.id <=> a.id : a.tracker <=> b.tracker }.collect(&:id), issues.collect(&:id)
               end
               def test_gantt
                 get :gantt, :project_id => 1
                 assert_response :success
                 assert_template 'gantt.rhtml'
                 assert_not_nil assigns(:gantt)
                 events = assigns(:gantt).events
                 assert_not_nil events
                 # Issue with start and due dates
                 i = Issue.find(1)
                 assert_not_nil i.due_date
                 assert events.include?(Issue.find(1))
                 # Issue with without due date but targeted to a version with date
                 i = Issue.find(2)
                 assert_nil i.due_date
                 assert events.include?(i)
               end
               def test_cross_project_gantt
                 get :gantt
                 assert_response :success
                 assert_template 'gantt.rhtml'
                 assert_not_nil assigns(:gantt)
                 events = assigns(:gantt).events
                 assert_not_nil events
               end
               def test_gantt_export_to_pdf
                 get :gantt, :project_id => 1, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:gantt)
               end
               def test_cross_project_gantt_export_to_pdf
                 get :gantt, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:gantt)
               end
               if Object.const_defined?(:Magick)
                 def test_gantt_image
                   get :gantt, :project_id => 1, :format => 'png'
                   assert_response :success
                   assert_equal 'image/png', @response.content_type
                 end
               else
                 puts "RMagick not installed. Skipping tests !!!"
               end
               def test_calendar
                 get :calendar, :project_id => 1
                 assert_response :success
                 assert_template 'calendar'
                 assert_not_nil assigns(:calendar)
               end
               def test_cross_project_calendar
                 get :calendar
                 assert_response :success
                 assert_template 'calendar'
                 assert_not_nil assigns(:calendar)
               end
               def test_changes
                 get :changes, :project_id => 1
                 assert_response :success
                 assert_not_nil assigns(:journals)
                 assert_equal 'application/atom+xml', @response.content_type
               end
               def test_show_routing
                 assert_routing(
                   {:method => :get, :path => '/issues/64'},
                   :controller => 'issues', :action => 'show', :id => '64'
                 )
               end
               def test_show_routing_formatted
                 assert_routing(
                   {:method => :get, :path => '/issues/2332.pdf'},
                   :controller => 'issues', :action => 'show', :id => '2332', :format => 'pdf'
                 )
                 assert_routing(
                   {:method => :get, :path => '/issues/23123.atom'},
                   :controller => 'issues', :action => 'show', :id => '23123', :format => 'atom'
                 )
               end
               def test_show_by_anonymous
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show.rhtml'
                 assert_not_nil assigns(:issue)
                 assert_equal Issue.find(1), assigns(:issue)
                 # anonymous role is allowed to add a note
                 assert_tag :tag => 'form',
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Notes/ } }
               end
               def test_show_by_manager
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :tag => 'form',
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Change properties/ } },
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Log time/ } },
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Notes/ } }
               end
               def test_show_should_not_disclose_relations_to_invisible_issues
                 Setting.cross_project_issue_relations = '1'
                 IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => 'relates')
                 # Relation to a private project issue
                 IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(4), :relation_type => 'relates')
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :div, :attributes => { :id => 'relations' },
                                  :descendant => { :tag => 'a', :content => /#2$/ }
                 assert_no_tag :div, :attributes => { :id => 'relations' },
                                     :descendant => { :tag => 'a', :content => /#4$/ }
               end
               def test_show_atom
                 get :show, :id => 2, :format => 'atom'
                 assert_response :success
                 assert_template 'changes.rxml'
                 # Inline image
                 assert @response.body.include?("&lt;img src=\"http://test.host/attachments/download/10\" alt=\"\" /&gt;")
               end
               def test_new_routing
                 assert_routing(
                   {:method => :get, :path => '/projects/1/issues/new'},
                   :controller => 'issues', :action => 'new', :project_id => '1'
                 )
                 assert_recognizes(
                   {:controller => 'issues', :action => 'new', :project_id => '1'},
                   {:method => :post, :path => '/projects/1/issues'}
                 )
               end
               def test_show_export_to_pdf
                 get :show, :id => 3, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:issue)
               end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag :tag => 'input', :attributes => { :name => 'issue[custom_field_values][2]',
                                                              :value => 'Default string' }
               end
               def test_get_new_without_tracker_id
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
                 assert_template 'new'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal Project.find(1).trackers.first, issue.tracker
               end
               def test_get_new_with_no_default_status_should_display_an_error
                 @request.session[:user_id] = 2
                 IssueStatus.delete_all
                 get :new, :project_id => 1
                 assert_response 500
                 assert_not_nil flash[:error]
                 assert_tag :tag => 'div', :attributes => { :class => /error/ },
                                           :content => /No default issue/
               end
               def test_get_new_with_no_tracker_should_display_an_error
                 @request.session[:user_id] = 2
                 Tracker.delete_all
                 get :new, :project_id => 1
                 assert_response 500
                 assert_not_nil flash[:error]
                 assert_tag :tag => 'div', :attributes => { :class => /error/ },
                                           :content => /No tracker/
               end
               def test_update_new_form
                 @request.session[:user_id] = 2
                 xhr :post, :new, :project_id => 1,
                                  :issue => {:tracker_id => 2,
                                             :subject => 'This is the test_new issue',
                                             :description => 'This is the description',
                                             :priority_id => 5}
                 assert_response :success
                 assert_template 'new'
               end
               def test_post_new
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :new, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_equal 2, issue.author_id
                 assert_equal 3, issue.tracker_id
                 assert_nil issue.estimated_hours
                 v = issue.custom_values.find(:first, :conditions => {:custom_field_id => 2})
                 assert_not_nil v
                 assert_equal 'Value for field 2', v.value
               end
               def test_post_new_and_continue
                 @request.session[:user_id] = 2
                 post :new, :project_id => 1,
                            :issue => {:tracker_id => 3,
                                       :subject => 'This is first issue',
                                       :priority_id => 5},
                            :continue => ''
                 assert_redirected_to :controller => 'issues', :action => 'new', :tracker_id => 3
               end
               def test_post_new_without_custom_fields_param
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :new, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
               end
               def test_post_new_with_required_custom_field_and_without_custom_fields_param
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 @request.session[:user_id] = 2
                 post :new, :project_id => 1,
                            :issue => {:tracker_id => 1,
                                       :subject => 'This is the test_new issue',
                                       :description => 'This is the description',
                                       :priority_id => 5}
                 assert_response :success
                 assert_template 'new'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
               end
               def test_post_new_with_watchers
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference 'Watcher.count', 2 do
                   post :new, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a new issue with watchers',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :watcher_user_ids => ['2', '3']}
                 end
                 issue = Issue.find_by_subject('This is a new issue with watchers')
                 assert_not_nil issue
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                 # Watchers added
                 assert_equal [2, 3], issue.watcher_user_ids.sort
                 assert issue.watched_by?(User.find(3))
                 # Watchers notified
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert [mail.bcc, mail.cc].flatten.include?(User.find(3).mail)
               end
               def test_post_new_should_send_a_notification
                 ActionMailer::Base.deliveries.clear
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :new, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_post_should_preserve_fields_values_on_validation_failure
                 @request.session[:user_id] = 2
                 post :new, :project_id => 1,
                            :issue => {:tracker_id => 1,
                                       # empty subject
                                       :subject => '',
                                       :description => 'This is a description',
                                       :priority_id => 6,
                                       :custom_field_values => {'1' => 'Oracle', '2' => 'Value for field 2'}}
                 assert_response :success
                 assert_template 'new'
                 assert_tag :textarea, :attributes => { :name => 'issue[description]' },
                                       :content => 'This is a description'
                 assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                     :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                    :value => '6' },
                                                                   :content => 'High' }
                 # Custom fields
                 assert_tag :select, :attributes => { :name => 'issue[custom_field_values][1]' },
                                     :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                    :value => 'Oracle' },
                                                                   :content => 'Oracle' }
                 assert_tag :input, :attributes => { :name => 'issue[custom_field_values][2]',
                                                     :value => 'Value for field 2'}
               end
               def test_copy_routing
                 assert_routing(
                   {:method => :get, :path => '/projects/world_domination/issues/567/copy'},
                   :controller => 'issues', :action => 'new', :project_id => 'world_domination', :copy_from => '567'
                 )
               end
               def test_copy_issue
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :copy_from => 1
                 assert_template 'new'
                 assert_not_nil assigns(:issue)
                 orig = Issue.find(1)
                 assert_equal orig.subject, assigns(:issue).subject
               end
               def test_edit_routing
                 assert_routing(
                   {:method => :get, :path => '/issues/1/edit'},
                   :controller => 'issues', :action => 'edit', :id => '1'
                 )
                 assert_recognizes( #TODO: use a PUT on the issue URI isntead, need to adjust form
                   {:controller => 'issues', :action => 'edit', :id => '1'},
                   {:method => :post, :path => '/issues/1/edit'}
                 )
               end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_not_nil assigns(:issue)
                 assert_equal Issue.find(1), assigns(:issue)
               end
               def test_get_edit_with_params
                 @request.session[:user_id] = 2
                 get :edit, :id => 1, :issue => { :status_id => 5, :priority_id => 7 }
                 assert_response :success
                 assert_template 'edit'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal 5, issue.status_id
                 assert_tag :select, :attributes => { :name => 'issue[status_id]' },
                                     :child => { :tag => 'option',
                                                 :content => 'Closed',
                                                 :attributes => { :selected => 'selected' } }
                 assert_equal 7, issue.priority_id
                 assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                     :child => { :tag => 'option',
                                                 :content => 'Urgent',
                                                 :attributes => { :selected => 'selected' } }
               end
               def test_reply_routing
                 assert_routing(
                   {:method => :post, :path => '/issues/1/quoted'},
                   :controller => 'issues', :action => 'reply', :id => '1'
                 )
               end
               def test_reply_to_issue
                 @request.session[:user_id] = 2
                 get :reply, :id => 1
                 assert_response :success
                 assert_select_rjs :show, "update"
               end
               def test_reply_to_note
                 @request.session[:user_id] = 2
                 get :reply, :id => 1, :journal_id => 2
                 assert_response :success
                 assert_select_rjs :show, "update"
               end
               def test_post_edit_without_custom_fields_param
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 assert_equal '125', issue.custom_value_for(2).value
                 old_subject = issue.subject
                 new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 2) do
                     post :edit, :id => 1, :issue => {:subject => new_subject,
                                                      :priority_id => '6',
                                                      :category_id => '1' # no change
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal new_subject, issue.subject
                 # Make sure custom fields were not cleared
                 assert_equal '125', issue.custom_value_for(2).value
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert mail.body.include?("Subject changed from #{old_subject} to #{new_subject}")
               end
               def test_post_edit_with_custom_field_change
                 @request.session[:user_id] = 2
                 issue = Issue.find(1)
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 3) do
                     post :edit, :id => 1, :issue => {:subject => 'Custom field change',
                                                      :priority_id => '6',
                                                      :category_id => '1', # no change
                                                      :custom_field_values => { '2' => 'New custom value' }
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal 'New custom value', issue.custom_value_for(2).value
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert mail.body.include?("Searchable field changed from 125 to New custom value")
               end
               def test_post_edit_with_status_and_assignee_change
                 issue = Issue.find(1)
                 assert_equal 1, issue.status_id
                 @request.session[:user_id] = 2
                 assert_difference('TimeEntry.count', 0) do
                   post :edit,
                        :id => 1,
                        :issue => { :status_id => 2, :assigned_to_id => 3 },
                        :notes => 'Assigned to dlopper',
                        :time_entry => { :hours => '', :comments => '', :activity_id => TimeEntryActivity.first }
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal 2, issue.status_id
                 j = issue.journals.find(:first, :order => 'id DESC')
                 assert_equal 'Assigned to dlopper', j.notes
                 assert_equal 2, j.details.size
                 mail = ActionMailer::Base.deliveries.last
                 assert mail.body.include?("Status changed from New to Assigned")
                 # subject should contain the new status
                 assert mail.subject.include?("(#{ IssueStatus.find(2).name })")
               end
               def test_post_edit_with_note_only
                 notes = 'Note added by IssuesControllerTest#test_update_with_note_only'
                 # anonymous user
                 post :edit,
                      :id => 1,
                      :notes => notes
                 assert_redirected_to :action => 'show', :id => '1'
                 j = Issue.find(1).journals.find(:first, :order => 'id DESC')
                 assert_equal notes, j.notes
                 assert_equal 0, j.details.size
                 assert_equal User.anonymous, j.user
                 mail = ActionMailer::Base.deliveries.last
                 assert mail.body.include?(notes)
               end
               def test_post_edit_with_note_and_spent_time
                 @request.session[:user_id] = 2
                 spent_hours_before = Issue.find(1).spent_hours
                 assert_difference('TimeEntry.count') do
                   post :edit,
                        :id => 1,
                        :notes => '2.5 hours added',
                        :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first }
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 j = issue.journals.find(:first, :order => 'id DESC')
                 assert_equal '2.5 hours added', j.notes
                 assert_equal 0, j.details.size
                 t = issue.time_entries.find(:first, :order => 'id DESC')
                 assert_not_nil t
                 assert_equal 2.5, t.hours
                 assert_equal spent_hours_before + 2.5, issue.spent_hours
               end
               def test_post_edit_with_attachment_only
                 set_tmp_attachments_directory
                 # Delete all fixtured journals, a race condition can occur causing the wrong
                 # journal to get fetched in the next find.
                 Journal.delete_all
                 # anonymous user
                 post :edit,
                      :id => 1,
                      :notes => '',
                      :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 assert_redirected_to :action => 'show', :id => '1'
                 j = Issue.find(1).journals.find(:first, :order => 'id DESC')
                 assert j.notes.blank?
                 assert_equal 1, j.details.size
                 assert_equal 'testfile.txt', j.details.first.value
                 assert_equal User.anonymous, j.user
                 mail = ActionMailer::Base.deliveries.last
                 assert mail.body.include?('testfile.txt')
               end
               def test_post_edit_with_no_change
                 issue = Issue.find(1)
                 issue.journals.clear
                 ActionMailer::Base.deliveries.clear
                 post :edit,
                      :id => 1,
                      :notes => ''
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert issue.journals.empty?
                 # No email should be sent
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_post_edit_should_send_a_notification
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 old_subject = issue.subject
                 new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                 post :edit, :id => 1, :issue => {:subject => new_subject,
                                                  :priority_id => '6',
                                                  :category_id => '1' # no change
                                                 }
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_post_edit_with_invalid_spent_time
                 @request.session[:user_id] = 2
                 notes = 'Note added by IssuesControllerTest#test_post_edit_with_invalid_spent_time'
                 assert_no_difference('Journal.count') do
                   post :edit,
                        :id => 1,
                        :notes => notes,
                        :time_entry => {"comments"=>"", "activity_id"=>"", "hours"=>"2z"}
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :textarea, :attributes => { :name => 'notes' },
                                       :content => notes
                 assert_tag :input, :attributes => { :name => 'time_entry[hours]', :value => "2z" }
               end
               def test_get_bulk_edit
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
               end
               def test_bulk_edit
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_edit, :ids => [1, 2], :priority_id => 7,
                                                  :assigned_to_id => '',
                                                  :custom_field_values => {'2' => ''},
                                                  :notes => 'Bulk editing'
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [7, 7], Issue.find_all_by_id([1, 2]).collect {|i| i.priority.id}
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_equal 'Bulk editing', journal.notes
                 assert_equal 1, journal.details.size
               end
               def test_bullk_edit_should_send_a_notification
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 post(:bulk_edit,
                      {
                        :ids => [1, 2],
                        :priority_id => 7,
                        :assigned_to_id => '',
                        :custom_field_values => {'2' => ''},
                        :notes => 'Bulk editing'
                      })
                 assert_response 302
                 assert_equal 2, ActionMailer::Base.deliveries.size
               end
               def test_bulk_edit_status
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_edit, :ids => [1, 2], :priority_id => '',
                                                  :assigned_to_id => '',
                                                  :status_id => '5',
                                                  :notes => 'Bulk editing status'
                 assert_response 302
                 issue = Issue.find(1)
                 assert issue.closed?
               end
               def test_bulk_edit_custom_field
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_edit, :ids => [1, 2], :priority_id => '',
                                                  :assigned_to_id => '',
                                                  :custom_field_values => {'2' => '777'},
                                                  :notes => 'Bulk editing custom field'
                 assert_response 302
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '777', issue.custom_value_for(2).value
                 assert_equal 1, journal.details.size
                 assert_equal '125', journal.details.first.old_value
                 assert_equal '777', journal.details.first.value
               end
               def test_bulk_unassign
                 assert_not_nil Issue.find(2).assigned_to
                 @request.session[:user_id] = 2
                 # unassign issues
                 post :bulk_edit, :ids => [1, 2], :notes => 'Bulk unassigning', :assigned_to_id => 'none'
                 assert_response 302
                 # check that the issues were updated
                 assert_nil Issue.find(2).assigned_to
               end
               def test_move_routing
                 assert_routing(
                   {:method => :get, :path => '/issues/1/move'},
                   :controller => 'issues', :action => 'move', :id => '1'
                 )
                 assert_recognizes(
                   {:controller => 'issues', :action => 'move', :id => '1'},
                   {:method => :post, :path => '/issues/1/move'}
                 )
               end
               def test_move_one_issue_to_another_project
                 @request.session[:user_id] = 2
                 post :move, :id => 1, :new_project_id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_equal 2, Issue.find(1).project_id
               end
               def test_bulk_move_to_another_project
                 @request.session[:user_id] = 2
                 post :move, :ids => [1, 2], :new_project_id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 # Issues moved to project 2
                 assert_equal 2, Issue.find(1).project_id
                 assert_equal 2, Issue.find(2).project_id
                 # No tracker change
                 assert_equal 1, Issue.find(1).tracker_id
                 assert_equal 2, Issue.find(2).tracker_id
               end
               def test_bulk_move_to_another_tracker
                 @request.session[:user_id] = 2
                 post :move, :ids => [1, 2], :new_tracker_id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_equal 2, Issue.find(1).tracker_id
                 assert_equal 2, Issue.find(2).tracker_id
               end
               def test_bulk_copy_to_another_project
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', 2 do
                   assert_no_difference 'Project.find(1).issues.count' do
                     post :move, :ids => [1, 2], :new_project_id => 2, :copy_options => {:copy => '1'}
                   end
                 end
                 assert_redirected_to 'projects/ecookbook/issues'
               end
               def test_context_menu_one_issue
                 @request.session[:user_id] = 2
                 get :context_menu, :ids => [1]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_tag :tag => 'a', :content => 'Edit',
                                         :attributes => { :href => '/issues/1/edit',
                                                          :class => 'icon-edit' }
                 assert_tag :tag => 'a', :content => 'Closed',
                                         :attributes => { :href => '/issues/1/edit?issue%5Bstatus_id%5D=5',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Immediate',
                                         :attributes => { :href => '/issues/bulk_edit?ids%5B%5D=1&amp;priority_id=8',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Dave Lopper',
                                         :attributes => { :href => '/issues/bulk_edit?assigned_to_id=3&amp;ids%5B%5D=1',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Copy',
                                         :attributes => { :href => '/projects/ecookbook/issues/1/copy',
                                                          :class => 'icon-copy' }
                 assert_tag :tag => 'a', :content => 'Move',
                                         :attributes => { :href => '/issues/move?ids%5B%5D=1',
                                                          :class => 'icon-move' }
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => '/issues/destroy?ids%5B%5D=1',
                                                          :class => 'icon-del' }
               end
               def test_context_menu_one_issue_by_anonymous
                 get :context_menu, :ids => [1]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => '#',
                                                          :class => 'icon-del disabled' }
               end
               def test_context_menu_multiple_issues_of_same_project
                 @request.session[:user_id] = 2
                 get :context_menu, :ids => [1, 2]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_tag :tag => 'a', :content => 'Edit',
                                         :attributes => { :href => '/issues/bulk_edit?ids%5B%5D=1&amp;ids%5B%5D=2',
                                                          :class => 'icon-edit' }
                 assert_tag :tag => 'a', :content => 'Immediate',
                                         :attributes => { :href => '/issues/bulk_edit?ids%5B%5D=1&amp;ids%5B%5D=2&amp;priority_id=8',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Dave Lopper',
                                         :attributes => { :href => '/issues/bulk_edit?assigned_to_id=3&amp;ids%5B%5D=1&amp;ids%5B%5D=2',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Move',
                                         :attributes => { :href => '/issues/move?ids%5B%5D=1&amp;ids%5B%5D=2',
                                                          :class => 'icon-move' }
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => '/issues/destroy?ids%5B%5D=1&amp;ids%5B%5D=2',
                                                          :class => 'icon-del' }
               end
               def test_context_menu_multiple_issues_of_different_project
                 @request.session[:user_id] = 2
                 get :context_menu, :ids => [1, 2, 4]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => '#',
                                                          :class => 'icon-del disabled' }
               end
               def test_destroy_routing
                 assert_recognizes( #TODO: use DELETE on issue URI (need to change forms)
                   {:controller => 'issues', :action => 'destroy', :id => '1'},
                   {:method => :post, :path => '/issues/1/destroy'}
                 )
               end
               def test_destroy_issue_with_no_time_entries
                 assert_nil TimeEntry.find_by_issue_id(2)
                 @request.session[:user_id] = 2
                 post :destroy, :id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil Issue.find_by_id(2)
               end
               def test_destroy_issues_with_time_entries
                 @request.session[:user_id] = 2
                 post :destroy, :ids => [1, 3]
                 assert_response :success
                 assert_template 'destroy'
                 assert_not_nil assigns(:hours)
                 assert Issue.find_by_id(1) && Issue.find_by_id(3)
               end
               def test_destroy_issues_and_destroy_time_entries
                 @request.session[:user_id] = 2
                 post :destroy, :ids => [1, 3], :todo => 'destroy'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_nil TimeEntry.find_by_id([1, 2])
               end
               def test_destroy_issues_and_assign_time_entries_to_project
                 @request.session[:user_id] = 2
                 post :destroy, :ids => [1, 3], :todo => 'nullify'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_nil TimeEntry.find(1).issue_id
                 assert_nil TimeEntry.find(2).issue_id
               end
               def test_destroy_issues_and_reassign_time_entries_to_another_issue
                 @request.session[:user_id] = 2
                 post :destroy, :ids => [1, 3], :todo => 'reassign', :reassign_to_id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_equal 2, TimeEntry.find(1).issue_id
                 assert_equal 2, TimeEntry.find(2).issue_id
               end
               def test_default_search_scope
                 get :index
                 assert_tag :div, :attributes => {:id => 'quick-search'},
                                  :child => {:tag => 'form',
                                             :child => {:tag => 'input', :attributes => {:name => 'issues', :type => 'hidden', :value => '1'}}}
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages