/
CSV.pm
376 lines (236 loc) · 7.66 KB
/
CSV.pm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
package Tie::Array::CSV;
use strict;
use warnings;
use Carp;
use Tie::File;
use Text::CSV;
use Tie::Array;
our @ISA = ('Tie::Array');
sub new {
my $class = shift;
croak "Must specify a file" unless @_;
my $file;
my %opts;
# handle one arg as either hashref (of opts) or file
if (@_ == 1) {
if (ref $_[0] eq 'HASH') {
%opts = %{ shift() };
} else {
$file = shift;
}
}
# handle file and hashref of opts
if (@_ == 2 and ref $_[1] eq 'HASH') {
$file = shift;
%opts = %{ shift() };
}
# handle file before hash of opts
if (@_ % 2) {
$file = shift;
}
# handle hash of opts
if (@_) {
%opts = @_;
}
# handle file passed has hash(ref) value to 'file' key
if (!$file and defined $opts{file}) {
$file = delete $opts{file};
}
# file wasn't specified as lone arg or as a hash opt
croak "Must specify a file" unless $file;
tie my @self, __PACKAGE__, $file, \%opts;
return \@self;
}
sub TIEARRAY {
my $class = shift;
my ($file, $opts) = @_;
my @tiefile;
tie @tiefile, 'Tie::File', $file, %{ $opts->{tie_file} || {} }
or croak "Cannot tie file $file";
my $csv = Text::CSV->new($opts->{text_csv} || {})
or croak "CSV (new) error: " . Text::CSV->error_diag();
my $self = {
file => \@tiefile,
csv => $csv,
};
bless $self, $class;
return $self;
}
sub FETCH {
my $self = shift;
my $index = shift;
my $line = $self->{file}[$index];
$self->{csv}->parse($line)
or croak "CSV parse error: " . $self->{csv}->error_diag();
my @fields = $self->{csv}->fields;
tie my @line, 'Tie::Array::CSV::Row', {
file => $self->{file},
line_num => $index,
fields => \@fields,
csv => $self->{csv},
};
return \@line;
}
sub STORE {
my $self = shift;
my ($index, $value) = @_;
$self->{csv}->combine(
ref $value ? @$value : ($value)
)
or croak "CSV combine error: " . $self->{csv}->error_diag();
$self->{file}[$index] = $self->{csv}->string;
}
sub FETCHSIZE {
my $self = shift;
return scalar @{ $self->{file} };
}
sub STORESIZE {
my $self = shift;
my $new_size = shift;
$#{ $self->{file} } = $new_size - 1;
}
package Tie::Array::CSV::Row;
use Carp;
use Tie::Array;
our @ISA = ('Tie::Array');
use overload
'@{}' => sub{ return @{ $_[0]{fields} } };
sub TIEARRAY {
my $class = shift;
my $self = shift;
bless $self, $class;
return $self;
}
sub FETCH {
my $self = shift;
my $index = shift;
return $self->{fields}[$index];
}
sub STORE {
my $self = shift;
my ($index, $value) = @_;
$self->{fields}[$index] = $value;
$self->_update;
}
sub FETCHSIZE {
my $self = shift;
return scalar @{ $self->{fields} };
}
sub STORESIZE {
my $self = shift;
my $new_size = shift;
my $return = (
$#{ $self->{fields} } = $new_size - 1
);
$self->_update;
return $return;
}
sub SHIFT {
my $self = shift;
my $value = shift @{ $self->{fields} };
$self->_update;
return $value;
}
sub UNSHIFT {
my $self = shift;
my $value = shift;
unshift @{ $self->{fields} }, $value;
$self->_update;
return $self->FETCHSIZE();
}
sub _update {
my $self = shift;
$self->{csv}->combine(@{ $self->{fields} })
or croak "CSV combine error: " . $self->{csv}->error_diag();
$self->{file}[$self->{line_num}] = $self->{csv}->string;
}
__END__
__POD__
=head1 NAME
Tie::Array::CSV - A tied array which combines the power of Tie::File and Text::CSV
=head1 SYNOPSIS
use strict; use warnings;
use Tie::Array::CSV;
tie my @file, 'Tie::Array::CSV', 'filename';
print $file[0][2];
$file[3][5] = "Camel";
=head1 DESCRIPTION
This module allows an array to be tied to a CSV file for reading and writing. The array is a standard Perl 2D array (i.e. an array of array references) which gives access to the row and column of the user's choosing. This is done using the well established modules:
=over
=item *
L<Tie::File>
=over
=item *
arbitrary line access
=item *
low memory use even for large files
=back
=item *
L<Text::CSV>
=over
=item *
row parsing
=item *
row updating
=item *
uses the speedy L<Text::CSV_XS> if installed
=back
=back
This module was inspired by L<Tie::CSV_File> which (sadly) hasn't been maintained. It also doesn't attempt to do any of the parsing (as that module did), but rather passes all of the heavy lifting to other modules.
=head1 CONSTRUCTORS
=head2 C<tie> Constructor
As with any tied array, the construction uses the C<tie> function.
tie my @file, 'Tie::Array::CSV', 'filename';
would tie the lexically scoped array C<@file> to the file C<filename> using this module. Following these three arguements to C<tie>, one may optionally pass a hashref containing additional configuration.
tie my @file, 'Tie::Array::CSV', 'filename', { opt_key => val, ... };
Of course, the magical Perl C<tie> can be scary for some, for those people there is the ...
=head2 C<new> Constructor
[ Added in version 0.03 ]
The class method C<new> constructor is more flexible in its calling. The constructor must be passed a file name, either as the first argument, or as the value to the option key C<file>. Options may be passed as key-value pairs or as a hash reference. This yields the many ways of calling C<new> shown below, one for every taste.
my $array = Tie::Array::CSV->new( 'filename' );
my $array = Tie::Array::CSV->new( 'filename', { opt_key => val, ... });
my $array = Tie::Array::CSV->new( 'filename', opt_key => val, ... );
my $array = Tie::Array::CSV->new( file => 'filename', opt_key => val, ... );
my $array = Tie::Array::CSV->new( { file => 'filename', opt_key => val, ... } );
It only returns a reference to the C<tie>d array due to a limitations in how C<tie> magic works.
N.B. Should a lone argument filename and a C<file> option key both be passed to the constructor, the lone argument wins.
=head2 Options
Currently the only options are "pass-through" options, sent to the constructors of the different modules used internally, read more about them in those module's documentation.
=over
=item *
tie_file - hashref of options which are passed to the L<Tie::File> constructor
=item *
text_csv - hashref of options which are passed to the L<Text::CSV> constructor
=back
example:
tie my @file, 'Tie::Array::CSV', 'filename', {
tie_file => {},
text_csv => { sep_char => ';' },
};
=head1 ERRORS
For simplicity this module C<croak>s on all errors, which are trappable using a C<$SIG{__DIE__}> handler.
=head1 CAVEATS
=over
=item *
Much of the functionality of normal arrays is mimicked using L<Tie::Array>. The interaction of this with L<Tie::File> should be mentioned in that certain actions may be very inefficient. For example, C<(un)shift>-ing the first row of data will probably involve L<Tie::Array> asking L<Tie::File> to move each row up one line, one-by-one. As a note, the intra-row C<(un)shift> does not suffer this problem.
=item *
Some effort had been made to allow for fields which contain linebreaks. Linebreaks would change line numbers used for row access by L<Tie::File>. This, unfortunately, moved the module far from its stated goals, and therefore far less powerful for its intended purposes. The decsion has been made (for now) not to support such files.
=back
=head1 SEE ALSO
=over
=item *
L<Tie::CSV_File> - inspiration for this module, but problematic
=item *
L<Tie::Array::DBD> - tie database connection to array
=item *
L<Tie::DBI> - similar but hash based
=back
=head1 SOURCE REPOSITORY
L<http://github.com/jberger/Tie-Array-CSV>
=head1 AUTHOR
Joel Berger, E<lt>joel.a.berger@gmail.comE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2011 by Joel Berger
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
=cut