@@ -, +, @@ - 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. Delete field 245 if 245$9 = 42 245 $a The art of computer programming $c Donald E. Knuth. $9 41 245 $a Bad title $c Bad author $9 42 prove t/SimpleMARC.t prove t/db_dependent/MarcModificationTemplates.t --- C4/MarcModificationTemplates.pm | 45 +++--- Koha/SimpleMARC.pm | 156 +++++++++++++-------- t/SimpleMARC.t | 302 ++++++++++++++++++++++++++-------------- 3 files changed, 316 insertions(+), 187 deletions(-) --- a/C4/MarcModificationTemplates.pm +++ a/C4/MarcModificationTemplates.pm @@ -524,55 +524,56 @@ sub ModifyRecordWithTemplate { } 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 ) { - if ( $action eq 'copy_field' ) { + @$field_numbers = ( $field_number ) + if $from_field ne $to_subfield + and $field_number; + if ( $action eq 'copy_fields' ) { copy_field({ record => $record, from_field => $from_field, @@ -584,16 +585,16 @@ sub ModifyRecordWithTemplate { 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' ) { @@ -608,7 +609,7 @@ sub ModifyRecordWithTemplate { replace => $to_regex_replace, modifiers => $to_regex_modifiers }, - n => $field_number, + field_numbers => $field_numbers, }); } elsif ( $action eq 'delete_field' ) { @@ -616,7 +617,7 @@ sub ModifyRecordWithTemplate { record => $record, field => $from_field, subfield => $from_subfield, - n => $field_number, + field_numbers => $field_numbers, }); } } --- a/Koha/SimpleMARC.pm +++ a/Koha/SimpleMARC.pm @@ -80,7 +80,7 @@ sub copy_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 ( ! ( $record && $fromFieldName && $toFieldName ) ) { return; } @@ -93,7 +93,7 @@ sub copy_field { from_field => $fromFieldName, to_field => $toFieldName, regex => $regex, - n => $n + field_numbers => $field_numbers, }); } else { _copy_subfield({ @@ -103,7 +103,7 @@ sub copy_field { to_field => $toFieldName, to_subfield => $toSubfieldName, regex => $regex, - n => $n + field_numbers => $field_numbers, }); } @@ -115,14 +115,14 @@ sub _copy_field { 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, }); } @@ -134,10 +134,12 @@ sub _copy_subfield { 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 }); @@ -149,6 +151,7 @@ sub update_field { my $fieldName = $params->{field}; my $subfieldName = $params->{subfield}; my @values = @{ $params->{values} }; + my $field_numbers = $params->{field_numbers} // []; if ( ! ( $record && $fieldName ) ) { return; } @@ -157,7 +160,7 @@ sub update_field { 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 }); } } @@ -194,9 +197,16 @@ sub _update_subfield { 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; @@ -236,12 +246,12 @@ sub read_field { 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 }); } } @@ -249,7 +259,7 @@ sub _read_field { 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 ); @@ -259,10 +269,12 @@ sub _read_field { 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 { @@ -281,7 +293,7 @@ sub _read_subfield { 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 ); @@ -293,16 +305,18 @@ sub _read_subfield { 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 @@ -314,28 +328,30 @@ sub field_exists { 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 { @@ -345,19 +361,32 @@ 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 @@ -381,7 +410,7 @@ sub 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 '' @@ -391,7 +420,7 @@ sub move_field { from_field => $fromFieldName, to_field => $toFieldName, regex => $regex, - n => $n, + field_numbers => $field_numbers, }); } else { _move_subfield({ @@ -401,7 +430,7 @@ sub move_field { to_field => $toFieldName, to_subfield => $toSubfieldName, regex => $regex, - n => $n, + field_numbers => $field_numbers, }); } } @@ -412,13 +441,14 @@ sub _move_field { 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', }); } @@ -431,11 +461,13 @@ sub _move_subfield { 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 }); @@ -444,7 +476,7 @@ sub _move_subfield { record => $record, field => $fromFieldName, subfield => $fromSubfieldName, - n => $n, + field_numbers => $field_numbers, }); } @@ -464,12 +496,12 @@ sub delete_field { 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 }); } } @@ -477,11 +509,13 @@ sub _delete_field { 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 ); } @@ -492,11 +526,13 @@ sub _delete_subfield { 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 ); @@ -510,12 +546,12 @@ sub _copy_move_field { 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 ) { --- a/t/SimpleMARC.t +++ a/t/SimpleMARC.t @@ -41,14 +41,14 @@ sub new_record { 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' ); @@ -60,10 +60,10 @@ subtest 'field_exists' => sub { ) ); - 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' ); }; @@ -83,42 +83,48 @@ subtest 'read_field' => sub { 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' ); }; @@ -148,9 +154,9 @@ subtest 'read_field' => sub { [ read_field( { - record => $record, - field => '650', - n => 1 + record => $record, + field => '650', + field_numbers => [1] } ) ], @@ -158,12 +164,20 @@ subtest 'read_field' => sub { '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' ); @@ -186,10 +200,12 @@ subtest 'update_field' => sub { } ); 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' } ); @@ -210,10 +226,12 @@ subtest 'update_field' => sub { } ); 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( @@ -288,25 +306,29 @@ subtest 'copy_field' => sub { } ); 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' ); @@ -335,14 +357,16 @@ subtest 'copy_field' => sub { 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' } ); @@ -354,14 +378,16 @@ subtest 'copy_field' => sub { 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' } ); @@ -430,7 +456,7 @@ subtest 'copy_field' => sub { to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' }, - n => 1 + field_numbers => [1] } ); @fields_651a = @@ -574,10 +600,12 @@ subtest 'copy_field' => sub { } ); 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' ); @@ -593,10 +621,12 @@ subtest 'copy_field' => sub { } ); 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' ); @@ -618,22 +648,38 @@ subtest 'copy_field' => sub { { 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" ); @@ -641,19 +687,27 @@ subtest 'copy_field' => sub { #- 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" ); @@ -682,22 +736,38 @@ subtest 'copy_field' => sub { } ); 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" ); @@ -752,7 +822,7 @@ subtest 'move_field' => sub { from_subfield => 'p', to_field => '954', to_subfield => 'p', - n => 1 + field_numbers => [1] } ); # Move the first field my @fields_952p = @@ -825,12 +895,20 @@ subtest 'move_field' => sub { 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" ); @@ -838,10 +916,10 @@ subtest 'move_field' => sub { #- 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( @@ -876,12 +954,20 @@ subtest 'move_field' => sub { 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" ); @@ -916,7 +1002,13 @@ subtest 'delete_field' => sub { ); 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' ); --