File perl-Array-Compare.spec of Package perl-Array-Compare

Overview Repositories Revisions Requests Users Attributes Meta

File perl-Array-Compare.spec of Package perl-Array-Compare (Revision 32cee4fc7eeaa283074f1e03f3030dc0)

Currently displaying revision 32cee4fc7eeaa283074f1e03f3030dc0 , Show latest

#
# spec file for package perl-Array-Compare
#
# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.

# Please submit bugfixes or comments via http://bugs.opensuse.org/
#

Name:           perl-Array-Compare
Version:        2.11
Release:        0
%define cpan_name Array-Compare
Summary:        Perl extension for comparing arrays
License:        Artistic-1.0 or GPL-1.0+
Group:          Development/Libraries/Perl
Url:            http://search.cpan.org/dist/Array-Compare/
Source:         http://www.cpan.org/authors/id/D/DA/DAVECROSS/%{cpan_name}-%{version}.tar.gz
BuildArch:      noarch
BuildRoot:      %{_tmppath}/%{name}-%{version}-build
BuildRequires:  perl
BuildRequires:  perl-macros
BuildRequires:  perl(Module::Build) >= 0.40
BuildRequires:  perl(Moo)
BuildRequires:  perl(Test::NoWarnings)
BuildRequires:  perl(Types::Standard)
Requires:       perl(Moo)
Requires:       perl(Types::Standard)
%{perl_requires}

%description
If you have two arrays and you want to know if they are the same or
different, then Array::Compare will be useful to you.

All comparisons are carried out via a comparator object. In the simplest
usage, you can create and use a comparator object like this:

my @arr1 = 0 .. 10;
  my @arr2 = 0 .. 10;

my $comp = Array::Compare->new;

if ($comp->compare(\@arr1, \@arr2)) {
    print "Arrays are the same\n";
  } else {
    print "Arrays are different\n";
  }

Notice that you pass references to the two arrays to the comparison method.

Internally the comparator compares the two arrays by using 'join' to turn
both arrays into strings and comparing the strings using 'eq'. In the
joined strings, the elements of the original arrays are separated with the
'^G' character. This can cause problems if your array data contains '^G'
characters as it is possible that two different arrays can be converted to
the same string.

To avoid this, it is possible to override the default separator character,
either by passing and alternative to the 'new' function

my $comp = Array::Compare->new(Sep => '|');

or by changing the seperator for an existing comparator object

$comp->Sep('|');

In general you should choose a separator character that won't appear in
your data.

You can also control whether or not whitespace within the elements of the
arrays should be considered significant when making the comparison. The
default is that all whitespace is significant. The alternative is for all
consecutive white space characters to be converted to a single space for
the pruposes of the comparison. Again, this can be turned on when creating
a comparator object:

my $comp = Array::Compare->new(WhiteSpace => 0);

or by altering an existing object:

$comp->WhiteSpace(0);

You can also control whether or not the case of the data is significant in
the comparison. The default is that the case of data is taken into account.
This can be changed in the standard ways when creating a new comparator
object:

my $comp = Array::Compare->new(Case => 0);

or by altering an existing object:

$comp->Case(0);

In addition to the simple comparison described above (which returns true if
the arrays are the same and false if they're different) there is also a
full comparison which returns a list containing the indexes of elements
which differ between the two arrays. If the arrays are the same it returns
an empty list. In scalar context the full comparison returns the length of
this list (i.e. the number of elements that differ). You can access the
full comparision in two ways. Firstly, there is a 'DefFull' attribute. If
this is 'true' then a full comparison if carried out whenever the 'compare'
method is called.

my $comp = Array::Compare->new(DefFull => 1);
  $comp->compare(\@arr1, \@arr2); # Full comparison

$comp->DefFull(0);
  $comp->compare(\@arr1, \@arr2); # Simple comparison

$comp->DefFull(1);
  $comp->compare(\@arr1, \@arr2); # Full comparison again

Secondly, you can access the full comparison method directly

$comp->full_compare(\@arr1, \@arr2);

For symmetry, there is also a direct method to use to call the simple
comparison.

$comp->simple_compare(\@arr1, \@arr2);

The final complication is the ability to skip elements in the comparison.
If you know that two arrays will always differ in a particular element but
want to compare the arrays _ignoring_ this element, you can do it with
Array::Compare without taking array slices. To do this, a comparator object
has an optional attribute called 'Skip' which is a reference to a hash. The
keys in this hash are the indexes of the array elements and the values
should be any true value for elements that should be skipped.

For example, if you want to compare two arrays, ignoring the values in
elements two and four, you can do something like this:

my %skip = (2 => 1, 4 => 1);
  my @a = (0, 1, 2, 3, 4, 5);
  my @b = (0, 1, X, 3, X, 5);

my $comp = Array::Compare->new(Skip => \%skip);

$comp->compare(\@a, \@b);

This should return _true_, as we are explicitly ignoring the columns which
differ.

Of course, having created a comparator object with no skip hash, it is
possible to add one later:

$comp->Skip({1 => 1, 2 => 1});

or:

my %skip = (1 => 1, 2 => 2);
  $comp->Skip(\%skip);

To reset the comparator so that no longer skips elements, set the skip hash
to an empty hash.

$comp->Skip({});

You can also check to see if one array is a permutation of another, i.e.
they contain the same elements but in a different order.

if ($comp->perm(\@a, \@b) {
    print "Arrays are perms\n";
  else {
    print "Nope. Arrays are completely different\n";
  }

In this case the values of 'WhiteSpace' and 'Case' are still used, but
'Skip' is ignored for, hopefully, obvious reasons.

%prep
%setup -q -n %{cpan_name}-%{version}
find . -type f -print0 | xargs -0 chmod 644

%build
%{__perl} Build.PL installdirs=vendor
./Build build flags=%{?_smp_mflags}

%check
./Build test

%install
./Build install destdir=%{buildroot} create_packlist=0
%perl_gen_filelist

%files -f %{name}.files
%defattr(-,root,root,755)
%doc Changes README

%changelog

Places

File perl-Array-Compare.spec of Package perl-Array-Compare (Revision 32cee4fc7eeaa283074f1e03f3030dc0)

Places