This patch series is a bugfix for the Marc modification templates tool.
Bug description:
If you want to do an action (delete/update/move/...) on a multivalued
field and if a condition is defined on the same field, it is highly
probable the resulted record will not be what you expect.
For example:
Deleting All (or the first) fields 650 if 245$a="Bad title" works with
the current code.
BUT if you want to delete All (or the first) fields 650 with a condition
on 650$9=42, and if at least one field matches the condition :
- if you have selected all, all fields 650 will be deleted, even the
ones who do not match the condition.
- if you have selected first, the first 650 field will be deleted, even
if it does not match the condition.
The expected behavior is to delete the fields matching the
condition (and not all the 650 fields).
What this patch does:
This patch introduces 2 changes in the logic of Koha::SimpleMARC.
The first change is a change of the prototypes for the 2 routines
field_exists and field_equals. Now they return the "field number" of the
matching fields.
The second change is the type of the "n" parameter for all routines
using it in Koha::SimpleMARC. Before this patch, the "n" parameter was a
boolean in most cases. If 0, the action was done on all fields, if 1
on the first one only. Now it is possible to specify the "field numbers"
(so the array of field numbers which is returned by field_exists or
field_equals) for all routines which had the n parameter.
Test plan for the patch series:
Note: This test plan describes a specific example, feel free to create
your own one.
0/ Define a marc modification template with the following action:
Delete field 245 if 245$9 = 42
1/ choose and export a record with several 245 fields.
For ex:
245
$a The art of computer programming
$c Donald E. Knuth.
$9 41
245
$a Bad title
$c Bad author
$9 42
2/ import it using the Stage MARC for import tool.
3/ verify the imported record does not contain any 245 field.
4/ apply all the patches from this bug report
5/ do again steps 2 and 3
6/ verify the imported record contains only one 245 field, the one with
245$9=41
7/ verify the unit tests passed:
prove t/SimpleMARC.t
prove t/db_dependent/MarcModificationTemplates.t
Signed-off-by: Kyle M Hall <kyle@bywatersolutions.com>
Signed-off-by: Brendan Gallagher <brendan@bywatersolutions.com>
Signed-off-by: Marcel de Rooy <m.de.rooy@rijksmuseum.nl>
Signed-off-by: Tomas Cohen Arazi <tomascohen@gmail.com>
}
my $do = 1;
+ my $field_numbers = [ $field_number ];
if ( $conditional ) {
if ( $conditional_comparison eq 'exists' ) {
- my $exists = field_exists({
- record =>$record,
+ $field_numbers = field_exists({
+ record => $record,
field => $conditional_field,
subfield => $conditional_subfield,
});
$do = $conditional eq 'if'
- ? $exists
- : not $exists;
+ ? @$field_numbers
+ : not @$field_numbers;
}
elsif ( $conditional_comparison eq 'not_exists' ) {
- my $exists = field_exists({
+ $field_numbers = field_exists({
record => $record,
field => $conditional_field,
subfield => $conditional_subfield
});
$do = $conditional eq 'if'
- ? not $exists
- : $exists;
+ ? not @$field_numbers
+ : @$field_numbers;
}
elsif ( $conditional_comparison eq 'equals' ) {
- my $equals = field_equals({
+ $field_numbers = field_equals({
record => $record,
value => $conditional_value,
field => $conditional_field,
subfield => $conditional_subfield,
- regex => $conditional_regex
});
$do = $conditional eq 'if'
- ? $equals
- : not $equals;
+ ? @$field_numbers
+ : not @$field_numbers;
}
elsif ( $conditional_comparison eq 'not_equals' ) {
- my $equals = field_equals({
+ $field_numbers = field_equals({
record => $record,
- value => $conditional_value,
field => $conditional_field,
- subfield => $conditional_subfield,
- regex => $conditional_regex
+ subfield => $conditional_subfield
});
$do = $conditional eq 'if'
- ? not $equals
- : $equals;
+ ? not @$field_numbers
+ : @$field_numbers;
}
}
if ( $do ) {
+ @$field_numbers = ( $field_number )
+ if $from_field ne $to_subfield
+ and $field_number;
if ( $action eq 'copy_field' ) {
copy_field({
record => $record,
replace => $to_regex_replace,
modifiers => $to_regex_modifiers
},
- n => $field_number,
+ field_numbers => $field_numbers,
});
}
-
elsif ( $action eq 'update_field' ) {
update_field({
record => $record,
field => $from_field,
subfield => $from_subfield,
values => [ $field_value ],
+ field_numbers => $field_numbers,
});
}
elsif ( $action eq 'move_field' ) {
replace => $to_regex_replace,
modifiers => $to_regex_modifiers
},
- n => $field_number,
+ field_numbers => $field_numbers,
});
}
elsif ( $action eq 'delete_field' ) {
record => $record,
field => $from_field,
subfield => $from_subfield,
- n => $field_number,
+ field_numbers => $field_numbers,
});
}
}
my $toFieldName = $params->{to_field};
my $toSubfieldName = $params->{to_subfield};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
if ( ! ( $record && $fromFieldName && $toFieldName ) ) { return; }
from_field => $fromFieldName,
to_field => $toFieldName,
regex => $regex,
- n => $n
+ field_numbers => $field_numbers,
});
} else {
_copy_subfield({
to_field => $toFieldName,
to_subfield => $toSubfieldName,
regex => $regex,
- n => $n
+ field_numbers => $field_numbers,
});
}
my $fromFieldName = $params->{from_field};
my $toFieldName = $params->{to_field};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
_copy_move_field({
record => $record,
from_field => $fromFieldName,
to_field => $toFieldName,
regex => $regex,
- n => $n
+ field_numbers => $field_numbers,
});
}
my $toFieldName = $params->{to_field};
my $toSubfieldName = $params->{to_subfield};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName });
- @values = ( $values[$n-1] ) if ( $n );
+ if ( @$field_numbers ) {
+ @values = map { $_ <= @values ? $values[ $_ - 1 ] : () } @$field_numbers;
+ }
_modify_values({ values => \@values, regex => $regex });
update_field({ record => $record, field => $toFieldName, subfield => $toSubfieldName, values => \@values });
my $fieldName = $params->{field};
my $subfieldName = $params->{subfield};
my @values = @{ $params->{values} };
+ my $field_numbers = $params->{field_numbers} // [];
if ( ! ( $record && $fieldName ) ) { return; }
die "This action is not implemented yet";
#_update_field({ record => $record, field => $fieldName, values => \@values });
} else {
- _update_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, values => \@values });
+ _update_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, values => \@values, field_numbers => $field_numbers });
}
}
my $subfieldName = $params->{subfield};
my @values = @{ $params->{values} };
my $dont_erase = $params->{dont_erase};
+ my $field_numbers = $params->{field_numbers} // [];
my $i = 0;
- if ( my @fields = $record->field( $fieldName ) ) {
+ my @fields = $record->field( $fieldName );
+
+ if ( @$field_numbers ) {
+ @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers;
+ }
+
+ if ( @fields ) {
unless ( $dont_erase ) {
@values = ($values[0]) x scalar( @fields )
if @values == 1;
my $record = $params->{record};
my $fieldName = $params->{field};
my $subfieldName = $params->{subfield};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
if ( not $subfieldName or $subfieldName eq '' ) {
- _read_field({ record => $record, field => $fieldName, n => $n });
+ _read_field({ record => $record, field => $fieldName, field_numbers => $field_numbers });
} else {
- _read_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n });
+ _read_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, field_numbers => $field_numbers });
}
}
my ( $params ) = @_;
my $record = $params->{record};
my $fieldName = $params->{field};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
my @fields = $record->field( $fieldName );
if $fieldName < 10;
my @values;
- if ( $n ) {
- if ( $n <= scalar( @fields ) ) {
- for my $sf ( $fields[$n - 1]->subfields ) {
- push @values, $sf->[1];
+ if ( @$field_numbers ) {
+ for my $field_number ( @$field_numbers ) {
+ if ( $field_number <= scalar( @fields ) ) {
+ for my $sf ( $fields[$field_number - 1]->subfields ) {
+ push @values, $sf->[1];
+ }
}
}
} else {
my $record = $params->{record};
my $fieldName = $params->{field};
my $subfieldName = $params->{subfield};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
my @fields = $record->field( $fieldName );
push( @values, @sf );
}
- return $n
- ? $values[$n-1]
- : @values;
+ if ( @values and @$field_numbers ) {
+ @values = map { $_ <= @values ? $values[ $_ - 1 ] : () } @$field_numbers;
+ }
+
+ return @values;
}
=head2 field_exists
- $bool = field_exists( $record, $fieldName[, $subfieldName ]);
+ @field_numbers = field_exists( $record, $fieldName[, $subfieldName ]);
- Returns true if the field exits, false otherwise.
+ Returns the field numbers or an empty array.
=cut
if ( ! $record ) { return; }
- my $return = 0;
- if ( $fieldName && $subfieldName ) {
- $return = $record->field( $fieldName ) && $record->subfield( $fieldName, $subfieldName );
- } elsif ( $fieldName ) {
- $return = $record->field( $fieldName ) && 1;
+ my @field_numbers = ();
+ my $current_field_number = 1;
+ for my $field ( $record->field( $fieldName ) ) {
+ if ( $subfieldName ) {
+ push @field_numbers, $current_field_number
+ if $field->subfield( $subfieldName );
+ } else {
+ push @field_numbers, $current_field_number;
+ }
+ $current_field_number++;
}
- return $return;
+ return \@field_numbers;
}
=head2 field_equals
- $bool = field_equals( $record, $value, $fieldName[, $subfieldName[, $regex [, $n ] ] ]);
+ $bool = field_equals( $record, $value, $fieldName[, $subfieldName[, $regex ] ]);
Returns true if the field equals the given value, false otherwise.
If a regular expression ( $regex ) is supplied, the value will be compared using
the given regex. Example: $regex = 'sought_text'
- If $n is passed, the Nth field of a repeatable series will be used for comparison.
- Set $n to 1 or leave empty for a non-repeatable field.
-
=cut
sub field_equals {
my $fieldName = $params->{field};
my $subfieldName = $params->{subfield};
my $regex = $params->{regex};
- my $n = $params->{n};
- $n = 1 unless ( $n ); ## $n defaults to first field of a repeatable field series
if ( ! $record ) { return; }
- my @field_values = read_field({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n });
- my $field_value = $field_values[$n-1];
-
- if ( $regex ) {
- return $field_value =~ m/$value/;
- } else {
- return $field_value eq $value;
+ my @field_numbers = ();
+ my $current_field_number = 1;
+ FIELDS: for my $field ( $record->field( $fieldName ) ) {
+ my @subfield_values = $subfieldName
+ ? $field->subfield( $subfieldName )
+ : map { $_->[1] } $field->subfields;
+
+ SUBFIELDS: for my $subfield_value ( @subfield_values ) {
+ if (
+ (
+ $regex and $subfield_value =~ m/$value/
+ ) or (
+ $subfield_value eq $value
+ )
+ ) {
+ push @field_numbers, $current_field_number;
+ last SUBFIELDS;
+ }
+ }
+ $current_field_number++;
}
+
+ return \@field_numbers;
}
=head2 move_field
my $toFieldName = $params->{to_field};
my $toSubfieldName = $params->{to_subfield};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
if ( not $fromSubfieldName or $fromSubfieldName eq ''
or not $toSubfieldName or $toSubfieldName eq ''
from_field => $fromFieldName,
to_field => $toFieldName,
regex => $regex,
- n => $n,
+ field_numbers => $field_numbers,
});
} else {
_move_subfield({
to_field => $toFieldName,
to_subfield => $toSubfieldName,
regex => $regex,
- n => $n,
+ field_numbers => $field_numbers,
});
}
}
my $fromFieldName = $params->{from_field};
my $toFieldName = $params->{to_field};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
+
_copy_move_field({
record => $record,
from_field => $fromFieldName,
to_field => $toFieldName,
regex => $regex,
- n => $n,
+ field_numbers => $field_numbers,
action => 'move',
});
}
my $toFieldName = $params->{to_field};
my $toSubfieldName = $params->{to_subfield};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
# Copy
my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName });
- @values = ( $values[$n-1] ) if $n;
+ if ( @$field_numbers ) {
+ @values = map { $_ <= @values ? $values[ $_ - 1 ] : () } @$field_numbers;
+ }
_modify_values({ values => \@values, regex => $regex });
_update_subfield({ record => $record, field => $toFieldName, subfield => $toSubfieldName, dont_erase => 1, values => \@values });
record => $record,
field => $fromFieldName,
subfield => $fromSubfieldName,
- n => $n,
+ field_numbers => $field_numbers,
});
}
my $record = $params->{record};
my $fieldName = $params->{field};
my $subfieldName = $params->{subfield};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
if ( not $subfieldName or $subfieldName eq '' ) {
- _delete_field({ record => $record, field => $fieldName, n => $n });
+ _delete_field({ record => $record, field => $fieldName, field_numbers => $field_numbers });
} else {
- _delete_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n });
+ _delete_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, field_numbers => $field_numbers });
}
}
my ( $params ) = @_;
my $record = $params->{record};
my $fieldName = $params->{field};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
my @fields = $record->field( $fieldName );
- @fields = ( $fields[$n-1] ) if ( $n );
+ if ( @$field_numbers ) {
+ @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers;
+ }
foreach my $field ( @fields ) {
$record->delete_field( $field );
}
my $record = $params->{record};
my $fieldName = $params->{field};
my $subfieldName = $params->{subfield};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers} // [];
my @fields = $record->field( $fieldName );
- @fields = ( $fields[$n-1] ) if ( $n );
+ if ( @$field_numbers ) {
+ @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers;
+ }
foreach my $field ( @fields ) {
$field->delete_subfield( code => $subfieldName );
my $fromFieldName = $params->{from_field};
my $toFieldName = $params->{to_field};
my $regex = $params->{regex};
- my $n = $params->{n};
+ my $field_numbers = $params->{field_numbers};
my $action = $params->{action} || 'copy';
my @fields = $record->field( $fromFieldName );
- if ( $n and $n <= scalar( @fields ) ) {
- @fields = ( $fields[$n - 1] );
+ if ( @$field_numbers ) {
+ @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers;
}
for my $field ( @fields ) {
subtest 'field_exists' => sub {
plan tests => 3;
my $record = new_record;
- is(
+ is_deeply(
field_exists( { record => $record, field => '650', subfield => 'a' } ),
- 'Computer programming.',
+ [1],
'650$a exists'
);
- is(
+ is_deeply(
field_exists( { record => $record, field => '650', subfield => 'b' } ),
- undef,
+ [],
'650$b does not exist'
);
)
);
- is(
+ is_deeply(
field_exists( { record => $record, field => '650', subfield => 'a' } ),
- 'Computer programming.',
- '650$a exists, field_exists returns the first one'
+ [ 1, 2 ],
+ '650$a exists, field_exists returns the 2 field numbers'
);
};
my @fields_650a =
read_field( { record => $record, field => '650', subfield => 'a' } );
- is( $fields_650a[0], 'Computer programming.', 'first 650$a' );
- is( $fields_650a[1], 'Computer algorithms.', 'second 650$a' );
- is(
- read_field(
- {
- record => $record,
- field => '650',
- subfield => 'a',
- n => 1
- }
- ),
- 'Computer programming.',
+ is_deeply( $fields_650a[0], 'Computer programming.', 'first 650$a' );
+ is_deeply( $fields_650a[1], 'Computer algorithms.', 'second 650$a' );
+ is_deeply(
+ [
+ read_field(
+ {
+ record => $record,
+ field => '650',
+ subfield => 'a',
+ field_numbers => [1]
+ }
+ )
+ ],
+ ['Computer programming.'],
'first 650$a bis'
);
- is(
- read_field(
- {
- record => $record,
- field => '650',
- subfield => 'a',
- n => 2
- }
- ),
- 'Computer algorithms.',
+ is_deeply(
+ [
+ read_field(
+ {
+ record => $record,
+ field => '650',
+ subfield => 'a',
+ field_numbers => [2]
+ }
+ )
+ ],
+ ['Computer algorithms.'],
'second 650$a bis'
);
- is(
- read_field(
- {
- record => $record,
- field => '650',
- subfield => 'a',
- n => 3
- }
- ),
- undef,
+ is_deeply(
+ [
+ read_field(
+ {
+ record => $record,
+ field => '650',
+ subfield => 'a',
+ field_numbers => [3]
+ }
+ )
+ ],
+ [],
'There is no 3 650$a'
);
};
[
read_field(
{
- record => $record,
- field => '650',
- n => 1
+ record => $record,
+ field => '650',
+ field_numbers => [1]
}
)
],
'Get the all subfield values for the first field 650'
);
is_deeply(
- [ read_field( { record => $record, field => '650', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '650', field_numbers => [2] }
+ )
+ ],
[ 'Computer algorithms.', '463' ],
'Get the all subfield values for the second field 650'
);
is_deeply(
- [ read_field( { record => $record, field => '650', n => 3 } ) ],
+ [
+ read_field(
+ { record => $record, field => '650', field_numbers => [3] }
+ )
+ ],
[],
'Get the all subfield values for the third field 650 which does not exist'
);
}
);
is_deeply(
- read_field(
- { record => $record, field => '952', subfield => 'p' }
- ),
- '3010023918',
+ [
+ read_field(
+ { record => $record, field => '952', subfield => 'p' }
+ )
+ ],
+ ['3010023918'],
'update existing subfield 952$p'
);
delete_field( { record => $record, field => '952' } );
}
);
is_deeply(
- read_field(
- { record => $record, field => '952', subfield => 'p' }
- ),
- '3010023918',
+ [
+ read_field(
+ { record => $record, field => '952', subfield => 'p' }
+ )
+ ],
+ ['3010023918'],
'create subfield 952$p'
);
is_deeply(
}
);
is_deeply(
- read_field(
- { record => $record, field => '245', subfield => 'a' }
- ),
- 'The art of computer programming',
+ [
+ read_field(
+ { record => $record, field => '245', subfield => 'a' }
+ )
+ ],
+ ['The art of computer programming'],
'After copy 245$a still exists'
);
is_deeply(
- read_field(
- { record => $record, field => '246', subfield => 'a' }
- ),
- 'The art of computer programming',
+ [
+ read_field(
+ { record => $record, field => '246', subfield => 'a' }
+ )
+ ],
+ ['The art of computer programming'],
'246$a is a new field'
);
delete_field( { record => $record, field => '246' } );
- is(
+ is_deeply(
field_exists(
{ record => $record, field => '246', subfield => 'a' }
),
- undef,
+ [],
'246$a does not exist anymore'
);
from_subfield => 'a',
to_field => '651',
to_subfield => 'a',
- n => 1
+ field_numbers => [1]
}
);
is_deeply(
- read_field(
- { record => $record, field => '651', subfield => 'a' }
- ),
- 'Computer programming.',
+ [
+ read_field(
+ { record => $record, field => '651', subfield => 'a' }
+ )
+ ],
+ ['Computer programming.'],
'Copy first field 650$a'
);
delete_field( { record => $record, field => '652' } );
from_subfield => 'a',
to_field => '651',
to_subfield => 'a',
- n => 2
+ field_numbers => [2]
}
);
is_deeply(
- read_field(
- { record => $record, field => '651', subfield => 'a' }
- ),
- 'Computer algorithms.',
+ [
+ read_field(
+ { record => $record, field => '651', subfield => 'a' }
+ )
+ ],
+ ['Computer algorithms.'],
'Copy second field 650$a'
);
delete_field( { record => $record, field => '651' } );
to_field => '651',
to_subfield => 'a',
regex => { search => 'Computer', replace => 'The art of' },
- n => 1
+ field_numbers => [1]
}
);
@fields_651a =
}
);
is_deeply(
- read_field(
- { record => $record, field => '245', subfield => 'a' }
- ),
- 'BEGIN The art of computer programming',
+ [
+ read_field(
+ { record => $record, field => '245', subfield => 'a' }
+ )
+ ],
+ ['BEGIN The art of computer programming'],
'Update a subfield: add a string at the beginning'
);
}
);
is_deeply(
- read_field(
- { record => $record, field => '245', subfield => 'a' }
- ),
- 'The art of computer programming END',
+ [
+ read_field(
+ { record => $record, field => '245', subfield => 'a' }
+ )
+ ],
+ ['The art of computer programming END'],
'Update a subfield: add a string at the end'
);
{ record => $record, from_field => '952', to_field => '953' } );
my @fields_952 = read_field( { record => $record, field => '952' } );
is_deeply(
- [ read_field( { record => $record, field => '952', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '952', field_numbers => [1] }
+ )
+ ],
[ '3010023917', 'BK', 'GEN', '2001-06-25' ],
"copy all: original first field still exists"
);
is_deeply(
- [ read_field( { record => $record, field => '952', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '952', field_numbers => [2] }
+ )
+ ],
[ '3010023918', 'CD' ],
"copy all: original second field still exists"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [1] }
+ )
+ ],
[ '3010023917', 'BK', 'GEN', '2001-06-25' ],
"copy all: first original fields has been copied"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [2] }
+ )
+ ],
[ '3010023918', 'CD' ],
"copy all: second original fields has been copied"
);
#- copy only the first field
copy_field(
{
- record => $record,
- from_field => '953',
- to_field => '954',
- n => 1
+ record => $record,
+ from_field => '953',
+ to_field => '954',
+ field_numbers => [1]
}
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [1] }
+ )
+ ],
[ '3010023917', 'BK', 'GEN', '2001-06-25' ],
"copy first: first original fields has been copied"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [2] }
+ )
+ ],
[ '3010023918', 'CD' ],
"copy first: second original fields has been copied"
);
}
);
is_deeply(
- [ read_field( { record => $record, field => '952', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '952', field_numbers => [1] }
+ )
+ ],
[ '3010023917', 'BK', 'GEN', '2001-06-25' ],
"copy all with regex: original first field still exists"
);
is_deeply(
- [ read_field( { record => $record, field => '952', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '952', field_numbers => [2] }
+ )
+ ],
[ '3010023918', 'CD' ],
"copy all with regex: original second field still exists"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [1] }
+ )
+ ],
[ '4242423917', 'BK', 'GEN', '2001-06-25' ],
"copy all wirh regex: first original fields has been copied"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [2] }
+ )
+ ],
[ '4242423918', 'CD' ],
"copy all with regex: second original fields has been copied"
);
from_subfield => 'p',
to_field => '954',
to_subfield => 'p',
- n => 1
+ field_numbers => [1]
}
); # Move the first field
my @fields_952p =
is_deeply( [ read_field( { record => $record, field => '952' } ) ],
[], "original fields don't exist" );
is_deeply(
- [ read_field( { record => $record, field => '953', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [1] }
+ )
+ ],
[ '3010023917', 'BK', 'GEN', '2001-06-25' ],
"first original fields has been copied"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [2] }
+ )
+ ],
[ '3010023917', 'BK' ],
"second original fields has been copied"
);
#- Move only the first field
move_field(
{
- record => $record,
- from_field => '953',
- to_field => '954',
- n => 1
+ record => $record,
+ from_field => '953',
+ to_field => '954',
+ field_numbers => [1]
}
);
is_deeply(
is_deeply( [ read_field( { record => $record, field => '952' } ) ],
[], "use a regex, original fields don't exist" );
is_deeply(
- [ read_field( { record => $record, field => '953', n => 1 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [1] }
+ )
+ ],
[ '3010023917', 'DVD', 'GEN', '2001-06-25' ],
"use a regex, first original fields has been copied"
);
is_deeply(
- [ read_field( { record => $record, field => '953', n => 2 } ) ],
+ [
+ read_field(
+ { record => $record, field => '953', field_numbers => [2] }
+ )
+ ],
[ '3010023917', 'DVD' ],
"use a regex, second original fields has been copied"
);
);
delete_field(
- { record => $record, field => '952', subfield => 'p', n => 1 } );
+ {
+ record => $record,
+ field => '952',
+ subfield => 'p',
+ field_numbers => [1]
+ }
+ );
my @fields_952p =
read_field( { record => $record, field => '952', subfield => 'p' } );
is_deeply( \@fields_952p, ['3010023917'], 'Delete first 952$p' );