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
-                 CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
+                 export = FCSV.generate(:col_sep => 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
-                 CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
+                 export = FCSV.generate(:col_sep => 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
-                 CSV::Writer.generate(export, l(:general_csv_separator)) do |csv|
+                 export = FCSV.generate(:col_sep => 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