Package: deb-perl-macros
Version: 0.1-27.1
Architecture: all
Maintainer: Victor Zhestkov <vzhestkov@suse.com>
Installed-Size: 42
Depends: perl
Filename: all/deb-perl-macros_0.1-27.1_all.deb
Size: 2822
MD5sum: 15a83c34cd956a5ebb9e37370b433135
SHA1: 5c7b775b499fbf1816a2b0e65850df975518918c
SHA256: e6c7115a40d56a05464380db7fca6a5e354cfbcd42833b9082576b2291925607
Priority: optional
Homepage: https://build.opensuse.org/package/show/systemsmanagement:saltstack:bundle:debbuild/deb-perl-macros
Description: Perl RPM macros for debbuild
 Perl RPM macros for debbuild

Package: debbuild
Version: 24.12.0-39.2
Architecture: all
Maintainer: debbuild developers <https://github.com/debbuild/debbuild>
Installed-Size: 209
Depends: liblocale-gettext-perl,lsb-release,xz-utils,bash,bzip2,dpkg,dpkg-dev,fakeroot,gzip,patch,pax,perl
Recommends: dpkg-sig,git-core,quilt,unzip,zip,zstd,debbuild-lua-support
Suggests: rpm
Filename: all/debbuild_24.12.0-39.2_all.deb
Size: 54902
MD5sum: 8c6318c4a4497671c805cb6ec1a07a8c
SHA1: 7bff5744740b9805009dfccc9927f9394eb857bd
SHA256: 2239f528866cf5eb61ccdb78394f2e6b5afce8ca4fabb9755faea08e3987e723
Section: devel
Priority: optional
Homepage: https://github.com/debbuild/debbuild
Description: Build Debian-compatible .deb packages from RPM .spec files
 debbuild attempts to build Debian-friendly semi-native packages from
 RPM spec files, RPM-friendly tarballs, and RPM source packages
 (.src.rpm files).  It accepts most of the options rpmbuild does, and
 should be able to interpret most spec files usefully.

Package: debbuild-lua-support
Version: 24.12.0-39.2
Architecture: all
Maintainer: debbuild developers <https://github.com/debbuild/debbuild>
Installed-Size: 32
Depends: debbuild (= 24.12.0-39.2),liblua-api-perl
Filename: all/debbuild-lua-support_24.12.0-39.2_all.deb
Size: 8544
MD5sum: 9ef3c2106343748505fcf78362e1e106
SHA1: 8a08bcb4bb58144fbcf26be5be11067cbf412023
SHA256: df6430d4ad0752f5af130d6c2a69ac20dc10b02f2ae0c05ce25c0de3016e5daf
Section: devel
Priority: optional
Homepage: https://github.com/debbuild/debbuild
Description: Lua macro support for debbuild
 This package adds the dependencies to support RPM macros
 written the Lua programming language.

Package: debbuild-macros
Version: 0.0.8-28.2
Architecture: all
Maintainer: debbuild developers <https://github.com/debbuild/debbuild>
Installed-Size: 126
Depends: debbuild (>= 22.02.1)
Provides: debbuild-macros-debpkg,debbuild-macros-cmake,cmake-deb-macros,debbuild-macros-mga-mkrel,debbuild-macros-mga-mklibname,mga-deb-macros,debbuild-macros-python,debbuild-macros-python2,debbuild-macros-python3,python-deb-macros,python2-deb-macros,python3-deb-macros,debbuild-macros-perl,perl-deb-macros,debbuild-macros-ruby,ruby-deb-macros,debbuild-macros-golang,go-deb-macros,golang-deb-macros,debbuild-macros-apache2,apache2-deb-macros,debbuild-macros-gpgverify,debbuild-macros-vpath,debbuild-macros-ninja,ninja-deb-macros,debbuild-macros-meson,meson-deb-macros,debbuild-macros-apparmor,apparmor-deb-macros,debbuild-macros-firewalld,firewalld-deb-macros,debbuild-macros-systemd,systemd-deb-macros
Filename: all/debbuild-macros_0.0.8-28.2_all.deb
Size: 25548
MD5sum: d0366214635406615693ee2b1b1caf4d
SHA1: 98d10e6ab28ff3c029e8b88c16081355c16cdb2e
SHA256: 469c4efbcc1cff67677c3d4a014cc6e2b3182f265bb4e86a78efca748db7c598
Section: devel
Priority: optional
Homepage: https://github.com/debbuild/debbuild-macros
Description: Various macros for extending debbuild functionality
 This package contains a set of RPM macros for debbuild,
 designed in such a manner that it is trivial to port RPM
 packaging to build Debian packages that are mostly in-line
 with Debian Policy.

Package: liblua5-1-5
Version: 5.1.5-29.1
Architecture: i386
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 689
Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-29.1)
Provides: lua51-libs (= 5.1.5-29.1),liblua5-1 (= 5.1.5-29.1)
Filename: i386/liblua5-1-5_5.1.5-29.1_i386.deb
Size: 239398
MD5sum: 14bf96a6b2d5192d8f1b1cd28b392712
SHA1: 4d42d3e7b0d41cacb62ed9acc02da7a2aa28f224
SHA256: 8f8714b24afa716db955af4ba6193e74e10cad7c23b27df29d5a9809568e1865
Section: System/Libraries
Priority: optional
Homepage: http://www.lua.org
Description: The Lua integration library
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 Lua combines procedural syntax (similar to Pascal) with
 data description constructs based on associative arrays and extensible
 semantics. Lua is dynamically typed, interpreted from byte codes, and
 has automatic memory management, making it suitable for configuration,
 scripting, and rapid prototyping. Lua is implemented as a small library
 of C functions, written in ANSI C.

Package: liblua5-1-5
Version: 5.1.5-29.1
Architecture: amd64
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 855
Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-29.1)
Provides: lua51-libs (= 5.1.5-29.1),liblua5-1 (= 5.1.5-29.1)
Filename: amd64/liblua5-1-5_5.1.5-29.1_amd64.deb
Size: 240606
MD5sum: a9929fde41ab7b36bc68fc87a378182f
SHA1: 6163886a4bf2fab7797aa44557a1993ec57eb0d0
SHA256: 98e64c96bb0d75b7b391f4d1cdfcbbaaa4dac2a68d278d3e1fd4616d035aa1b8
Section: System/Libraries
Priority: optional
Homepage: http://www.lua.org
Description: The Lua integration library
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 Lua combines procedural syntax (similar to Pascal) with
 data description constructs based on associative arrays and extensible
 semantics. Lua is dynamically typed, interpreted from byte codes, and
 has automatic memory management, making it suitable for configuration,
 scripting, and rapid prototyping. Lua is implemented as a small library
 of C functions, written in ANSI C.

Package: lua-macros
Version: 20210827-25.2
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 25
Depends: pkg-config
Filename: all/lua-macros_20210827-25.2_all.deb
Size: 1648
MD5sum: 1260ceecf0ab7d995604504b3912ed08
SHA1: a2a0b1997b0cceb145d498b28fc5515d6dc85add
SHA256: ed6e9a29b0a469238164fc84275b22a5eb9a0d50f233391430c8b340b021ba48
Section: Development/Languages/Other
Priority: optional
Homepage: https://www.lua.org
Description: Macros for lua language
 RPM macros for lua packaging

Package: lua51
Version: 5.1.5-29.1
Architecture: i386
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 1184
Depends: dpkg,libreadline6,libc6,libtinfo5
Provides: lua (= 5.1.5-29.1),lua-api (= 5.1)
Filename: i386/lua51_5.1.5-29.1_i386.deb
Size: 289846
MD5sum: ccb043576e5158d642dfc44d896c9a7e
SHA1: d64cc50f2b074e2f8dfd764f30f3263e570db3a6
SHA256: bd87fe22b8aa87f2244e7f2f41d9eae9234c7e12e11b9dfae83b02aea7a0413b
Section: Development/Languages/Other
Priority: optional
Homepage: http://www.lua.org
Description: Small Embeddable Language with Procedural Syntax
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 Lua combines procedural syntax (similar to Pascal) with
 data description constructs based on associative arrays and extensible
 semantics. Lua is dynamically typed, interpreted from byte codes, and
 has automatic memory management, making it suitable for configuration,
 scripting, and rapid prototyping. Lua is implemented as a small library
 of C functions, written in ANSI C.

Package: lua51
Version: 5.1.5-29.1
Architecture: amd64
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 1467
Depends: dpkg,libreadline6,libc6,libtinfo5
Provides: lua (= 5.1.5-29.1),lua-api (= 5.1)
Filename: amd64/lua51_5.1.5-29.1_amd64.deb
Size: 288862
MD5sum: cf943c40eb1f413595c75878c6231b9b
SHA1: 24d8923e6a6f4346d0ab1c4dfc5aceda79990dd8
SHA256: 30c11f81e9d33a906b2ac756d41991d9455d51d7ee4cea6d53a1a1c878d4605e
Section: Development/Languages/Other
Priority: optional
Homepage: http://www.lua.org
Description: Small Embeddable Language with Procedural Syntax
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 Lua combines procedural syntax (similar to Pascal) with
 data description constructs based on associative arrays and extensible
 semantics. Lua is dynamically typed, interpreted from byte codes, and
 has automatic memory management, making it suitable for configuration,
 scripting, and rapid prototyping. Lua is implemented as a small library
 of C functions, written in ANSI C.

Package: lua51-devel
Version: 5.1.5-29.1
Architecture: i386
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 1025
Depends: liblua5-1-5 (= 5.1.5-29.1),lua51 (= 5.1.5-29.1),lua-macros,dpkg
Provides: lua-devel (= 5.1.5-29.1),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-29.1)
Filename: i386/lua51-devel_5.1.5-29.1_i386.deb
Size: 307994
MD5sum: 2bfdc9703c8849b5c6731888b27a5405
SHA1: 64033bb5283c7ee51b6ef71f2b2115e459f76dc8
SHA256: 0d534f9a46c1dd64c2ac0ca56bba65e19e294703ddcee4bc385bd90d4801d51c
Section: Development/Libraries/C and C++
Priority: optional
Homepage: http://www.lua.org
Description: Development files for lua
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 This package contains files needed for embedding lua into your
 application.

Package: lua51-devel
Version: 5.1.5-29.1
Architecture: amd64
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 1521
Depends: liblua5-1-5 (= 5.1.5-29.1),lua51 (= 5.1.5-29.1),lua-macros,dpkg
Provides: lua-devel (= 5.1.5-29.1),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-29.1)
Filename: amd64/lua51-devel_5.1.5-29.1_amd64.deb
Size: 310434
MD5sum: 05a49b22bc07c363c08f732b66dd4d1d
SHA1: da8e1247db15b8831bedf910b8eef0ce8f76c195
SHA256: f495f5817194f4630d45ee37e87daef97fde423bf203ceeb3c60401550e2818b
Section: Development/Libraries/C and C++
Priority: optional
Homepage: http://www.lua.org
Description: Development files for lua
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 This package contains files needed for embedding lua into your
 application.

Package: lua51-doc
Version: 5.1.5-29.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 330
Filename: all/lua51-doc_5.1.5-29.1_all.deb
Size: 71522
MD5sum: 434a1f2fd4479cdf3376a4ac367c9b76
SHA1: f37b7f501f810db4304f9095b728a5e34bdb925b
SHA256: 2ddb0bc3c5af00fd63a2447957fb96f1c336072d3db168263a025503e5d7ad5c
Section: Documentation/HTML
Priority: optional
Homepage: http://www.lua.org
Description: Documentation for Lua, a small embeddable language
 Lua is a programming language originally designed for extending
 applications, but is also frequently used as a general-purpose,
 stand-alone language.
 .
 Lua combines procedural syntax (similar to Pascal) with
 data description constructs based on associative arrays and extensible
 semantics. Lua is dynamically typed, interpreted from byte codes, and
 has automatic memory management, making it suitable for configuration,
 scripting, and rapid prototyping. Lua is implemented as a small library
 of C functions, written in ANSI C.

Package: perl-capture-tiny
Version: 0.48-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 121
Filename: all/perl-capture-tiny_0.48-27.1_all.deb
Size: 30088
MD5sum: 5e9467f445b9a8f9726eeb2f8a8a1393
SHA1: 0591f4eaf5db9ad7c539f77dfef1119d480ea227
SHA256: 81064e2d4ee28b1980d1dcdb0b0b28563b9e56148da6455c94a8df542c371b37
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Capture-Tiny/
Description: Capture STDOUT and STDERR from Perl, XS or external programs
 Capture::Tiny provides a simple, portable way to capture almost anything
 sent to STDOUT or STDERR, regardless of whether it comes from Perl, from XS
 code or from an external program. Optionally, output can be teed so that it
 is captured while being passed through to the original filehandles. Yes, it
 even works on Windows (usually). Stop guessing which of a dozen capturing
 modules to use in any particular situation and just use this one.

Package: perl-carp
Version: 1.50-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 88
Filename: all/perl-carp_1.50-27.1_all.deb
Size: 22652
MD5sum: 7b66a6d4766d9a941c03827c7635962c
SHA1: b7d0526f764734368ec9ee0adf3a18de25d21f73
SHA256: 78487a1e48e92b9a861e804de82324ebfb51526f5aa7c63d0a5480ed98f74ca2
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Carp/
Description: Alternative Warn and Die for Modules
 The Carp routines are useful in your own modules because they act like
 'die()' or 'warn()', but with a message which is more likely to be useful
 to a user of your module. In the case of 'cluck()' and 'confess()', that
 context is a summary of every call in the call-stack; 'longmess()' returns
 the contents of the error message.
 .
 For a shorter message you can use 'carp()' or 'croak()' which report the
 error as being from where your module was called. 'shortmess()' returns the
 contents of this error message. There is no guarantee that that is where
 the error was, but it is a good educated guess.
 .
 'Carp' takes care not to clobber the status variables '$!' and '$^E' in the
 course of assembling its error messages. This means that a '$SIG{__DIE__}'
 or '$SIG{__WARN__}' handler can capture the error information held in those
 variables, if it is required to augment the error message, and if the code
 calling 'Carp' left useful values there. Of course, 'Carp' can't guarantee
 the latter.
 .
 You can also alter the way the output and logic of 'Carp' works, by
 changing some global variables in the 'Carp' namespace. See the section on
 'GLOBAL VARIABLES' below.
 .
 Here is a more complete description of how 'carp' and 'croak' work. What
 they do is search the call-stack for a function call stack where they have
 not been told that there shouldn't be an error. If every call is marked
 safe, they give up and give a full stack backtrace instead. In other words
 they presume that the first likely looking potential suspect is guilty.
 Their rules for telling whether a call shouldn't generate errors work as
 follows:
 .
 * 1.
 .
 Any call from a package to itself is safe.
 .
 * 2.
 .
 Packages claim that there won't be errors on calls to or from packages
 explicitly marked as safe by inclusion in '@CARP_NOT', or (if that array is
 empty) '@ISA'. The ability to override what @ISA says is new in 5.8.
 .
 * 3.
 .
 The trust in item 2 is transitive. If A trusts B, and B trusts C, then A
 trusts C. So if you do not override '@ISA' with '@CARP_NOT', then this
 trust relationship is identical to, "inherits from".
 .
 * 4.
 .
 Any call from an internal Perl module is safe. (Nothing keeps user modules
 from marking themselves as internal to Perl, but this practice is
 discouraged.)
 .
 * 5.
 .
 Any call to Perl's warning system (eg Carp itself) is safe. (This rule is
 what keeps it from reporting the error at the point where you call 'carp'
 or 'croak'.)
 .
 * 6.
 .
 '$Carp::CarpLevel' can be set to skip a fixed number of additional call
 levels. Using this is not recommended because it is very difficult to get
 it to behave correctly.

Package: perl-class-data-inheritable
Version: 0.09-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 55
Filename: all/perl-class-data-inheritable_0.09-27.1_all.deb
Size: 7182
MD5sum: 802db60677a5e794cb174c741503b14e
SHA1: 143abf0540053ec64b0f18b6d9be72b1d9e55e7c
SHA256: 53ef79c706a38207b02ce10116103778182ce09c6bdfc81c5548797da10ea616
Priority: optional
Homepage: https://metacpan.org/release/Class-Data-Inheritable
Description: Inheritable, overridable class data
 Class::Data::Inheritable is for creating accessor/mutators to class data.
 That is, if you want to store something about your class as a whole
 (instead of about a single object). This data is then inherited by your
 subclasses and can be overridden.
 .
 For example:
 .
   Pere::Ubu->mk_classdata('Suitcase');
 .
 will generate the method Suitcase() in the class Pere::Ubu.
 .
 This new method can be used to get and set a piece of class data.
 .
   Pere::Ubu->Suitcase('Red');
   $suitcase = Pere::Ubu->Suitcase;
 .
 The interesting part happens when a class inherits from Pere::Ubu:
 .
   package Raygun;
   use base qw(Pere::Ubu);
 .
   # Raygun's suitcase is Red.
   $suitcase = Raygun->Suitcase;
 .
 Raygun inherits its Suitcase class data from Pere::Ubu.
 .
 Inheritance of class data works analogous to method inheritance. As long as
 Raygun does not "override" its inherited class data (by using Suitcase() to
 set a new value) it will continue to use whatever is set in Pere::Ubu and
 inherit further changes:
 .
   # Both Raygun's and Pere::Ubu's suitcases are now Blue
   Pere::Ubu->Suitcase('Blue');
 .
 However, should Raygun decide to set its own Suitcase() it has now
 "overridden" Pere::Ubu and is on its own, just like if it had overridden a
 method:
 .
   # Raygun has an orange suitcase, Pere::Ubu's is still Blue.
   Raygun->Suitcase('Orange');
 .
 Now that Raygun has overridden Pere::Ubu further changes by Pere::Ubu no
 longer effect Raygun.
 .
   # Raygun still has an orange suitcase, but Pere::Ubu is using Samsonite.
   Pere::Ubu->Suitcase('Samsonite');

Package: perl-devel-stacktrace
Version: 2.04-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 113
Filename: all/perl-devel-stacktrace_2.04-27.1_all.deb
Size: 28440
MD5sum: 2945e28d45cbd49d3b25483799200477
SHA1: f608c31d64d21c60a127e509ff8d0726c816c512
SHA256: b9cdd304f94aee062e27733517e8ba270e8a58b3ad5e3774e9abbb1da1c13409
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/Devel-StackTrace
Description: An object representing a stack trace
 The 'Devel::StackTrace' module contains two classes, 'Devel::StackTrace'
 and Devel::StackTrace::Frame. These objects encapsulate the information
 that can retrieved via Perl's 'caller' function, as well as providing a
 simple interface to this data.
 .
 The 'Devel::StackTrace' object contains a set of 'Devel::StackTrace::Frame'
 objects, one for each level of the stack. The frames contain all the data
 available from 'caller'.
 .
 This code was created to support my Exception::Class::Base class (part of
 Exception::Class) but may be useful in other contexts.

Package: perl-devel-symdump
Version: 2.18-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 76
Depends: perl
Filename: all/perl-devel-symdump_2.18-27.1_all.deb
Size: 14342
MD5sum: 9021f94caf7a27bb45a9344accbfa2a9
SHA1: 4e365a890f1d238a26bf6c96a4295857af5f4f25
SHA256: 5aa6eb2e75ed15eae8ad68f84bd01b9725f2e19ab9b3256120f1ed98c871921c
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Devel-Symdump/
Description: Dump Symbol Names or the Symbol Table
 This little package serves to access the symbol table of perl.

Package: perl-exception-class
Version: 1.45-27.2
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 142
Depends: perl-class-data-inheritable,perl-devel-stacktrace
Filename: all/perl-exception-class_1.45-27.2_all.deb
Size: 39018
MD5sum: 27940d5a3944ceed8b5a8cdec77be12f
SHA1: 7ba6c0c6fe2c189e68d82cdc4d76843eb6ce7296
SHA256: 1daa678da2cd228181827590c1c6cb981efabe3ddee1c5f8a8b5e765a1340075
Priority: optional
Homepage: https://metacpan.org/release/Exception-Class
Description: Module that allows you to declare real exception classes in Perl
 *RECOMMENDATION 1*: If you are writing modern Perl code with Moose or Moo I
 highly recommend using Throwable instead of this module.
 .
 *RECOMMENDATION 2*: Whether or not you use Throwable, you should use
 Try::Tiny.
 .
 Exception::Class allows you to declare exception hierarchies in your
 modules in a "Java-esque" manner.
 .
 It features a simple interface allowing programmers to 'declare' exception
 classes at compile time. It also has a base exception class,
 Exception::Class::Base, that can be easily extended.
 .
 It is designed to make structured exception handling simpler and better by
 encouraging people to use hierarchies of exceptions in their applications,
 as opposed to a single catch-all exception class.
 .
 This module does not implement any try/catch syntax. Please see the "OTHER
 EXCEPTION MODULES (try/catch syntax)" section for more information on how
 to get this syntax.
 .
 You will also want to look at the documentation for Exception::Class::Base,
 which is the default base class for all exception objects created by this
 module.

Package: perl-extutils-cbuilder
Version: 0.280236-26.2
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 155
Depends: perl,perl-ipc-cmd,perl-perl-ostype
Filename: all/perl-extutils-cbuilder_0.280236-26.2_all.deb
Size: 39190
MD5sum: b24edc8d2af7a98db0c6f3765419b11b
SHA1: 48de86917478e189439c03a75a41a98dd6338dad
SHA256: 7264d698ce5fd392a5ef88e66c91d1413a71e8e678b5bc78e194fe6893fcd5cd
Priority: optional
Homepage: https://metacpan.org/release/ExtUtils-CBuilder
Description: Compile and link C code for Perl modules
 This module can build the C portions of Perl modules by invoking the
 appropriate compilers and linkers in a cross-platform manner. It was
 motivated by the 'Module::Build' project, but may be useful for other
 purposes as well. However, it is _not_ intended as a general cross-platform
 interface to all your C building needs. That would have been a much more
 ambitious goal!

Package: perl-extutils-makemaker
Version: 7.66-13.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 890
Filename: all/perl-extutils-makemaker_7.66-13.1_all.deb
Size: 304046
MD5sum: 296dc3f86cfae632aa51938165c6e131
SHA1: bfd23491a9cc8b1642ba8ec5a90174916c7580b6
SHA256: 557256ae3dbc8df5bfbfc29b1395dae75c48d719846f1ed9987b226e199798a4
Priority: optional
Homepage: https://metacpan.org/release/ExtUtils-MakeMaker
Description: Create a module Makefile
 This utility is designed to write a Makefile for an extension module from a
 Makefile.PL. It is based on the Makefile.SH model provided by Andy
 Dougherty and the perl5-porters.
 .
 It splits the task of generating the Makefile into several subroutines that
 can be individually overridden. Each subroutine returns the text it wishes
 to have written to the Makefile.
 .
 As there are various Make programs with incompatible syntax, which use
 operating system shells, again with incompatible syntax, it is important
 for users of this module to know which flavour of Make a Makefile has been
 written for so they'll use the correct one and won't have to face the
 possibly bewildering errors resulting from using the wrong one.
 .
 On POSIX systems, that program will likely be GNU Make; on Microsoft
 Windows, it will be either Microsoft NMake, DMake or GNU Make. See the
 section on the L</"MAKE"> parameter for details.
 .
 ExtUtils::MakeMaker (EUMM) is object oriented. Each directory below the
 current directory that contains a Makefile.PL is treated as a separate
 object. This makes it possible to write an unlimited number of Makefiles
 with a single invocation of WriteMakefile().
 .
 All inputs to WriteMakefile are Unicode characters, not just octets. EUMM
 seeks to handle all of these correctly. It is currently still not possible
 to portably use Unicode characters in module names, because this requires
 Perl to handle Unicode filenames, which is not yet the case on Windows.
 .
 See L<ExtUtils::MakeMaker::FAQ> for details of the design and usage.

Package: perl-extutils-pkgconfig
Version: 1.160000-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 61
Depends: pkg-config
Provides: libextutils-pkgconfig-perl (= 1.160000-27.1)
Filename: all/perl-extutils-pkgconfig_1.160000-27.1_all.deb
Size: 10424
MD5sum: 2a94fa509e1352fe2c9853837dd2bf9b
SHA1: 4841c8b24097e83a19c7ccae25ff1ce0c6fd4a92
SHA256: f71a1ecbb5d1a2782b20dad6e894e0f198192147fe423c425de19032797f38ec
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/ExtUtils-PkgConfig/
Description: Simplistic Interface to Pkg-Config
 The pkg-config program retrieves information about installed libraries,
 usually for the purposes of compiling against and linking to them.
 .
 ExtUtils::PkgConfig is a very simplistic interface to this utility,
 intended for use in the Makefile.PL of perl extensions which bind libraries
 that pkg-config knows. It is really just boilerplate code that you would've
 written yourself.

Package: perl-file-path
Version: 2.180000-27.3
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 107
Provides: libfile-path-perl (= 2.180000-27.3)
Filename: all/perl-file-path_2.180000-27.3_all.deb
Size: 30452
MD5sum: 51e1539360c3a82485366348a059bd0a
SHA1: 88eab12af18eb47c8805fe05a1f3b61d0ed250da
SHA256: 9376015d57a0918f73f4e805cacf1f695464eec3624e9987094f87b30b9a04da
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/File-Path
Description: Create or remove directory trees
 This module provides a convenient way to create directories of arbitrary
 depth and to delete an entire directory subtree from the filesystem.

Package: perl-file-temp
Version: 0.2311-27.3
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 207
Depends: perl-file-path,perl-parent
Filename: all/perl-file-temp_0.2311-27.3_all.deb
Size: 53214
MD5sum: 72794048ed1279ba528b9bae1f7b92de
SHA1: f6683f57e91ed428102cfe93827930a23e708942
SHA256: 654d27d6e19bf3c1ddcc7a572c53f23cde90c36cb030f4e541ce5e07bdf8b015
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/File-Temp
Description: Return name and handle of a temporary file safely
 'File::Temp' can be used to create and open temporary files in a safe way.
 There is both a function interface and an object-oriented interface. The
 File::Temp constructor or the tempfile() function can be used to return the
 name and the open filehandle of a temporary file. The tempdir() function
 can be used to create a temporary directory.
 .
 The security aspect of temporary file creation is emphasized such that a
 filehandle and filename are returned together. This helps guarantee that a
 race condition can not occur where the temporary file is created by another
 process between checking for the existence of the file and its opening.
 Additional security levels are provided to check, for example, that the
 sticky bit is set on world writable directories. See "safe_level" for more
 information.
 .
 For compatibility with popular C library functions, Perl implementations of
 the mkstemp() family of functions are provided. These are, mkstemp(),
 mkstemps(), mkdtemp() and mktemp().
 .
 Additionally, implementations of the standard POSIX tmpnam() and tmpfile()
 functions are provided if required.
 .
 Implementations of mktemp(), tmpnam(), and tempnam() are provided, but
 should be used with caution since they return only a filename that was
 valid when function was called, so cannot guarantee that the file will not
 exist by the time the caller opens the filename.
 .
 Filehandles returned by these functions support the seekable methods.

Package: perl-ipc-cmd
Version: 1.04-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 127
Depends: perl
Filename: all/perl-ipc-cmd_1.04-27.1_all.deb
Size: 32960
MD5sum: 1bbf4b94430beb88f9c416421e993951
SHA1: c608930a5969d9a77a12f9fedb812783b871f542
SHA256: 8867fe446b8956dcfac4a11a87a7524cb0731bc641164773d085cd60e0a59199
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/IPC-Cmd
Description: Finding and running system commands made easy
 IPC::Cmd allows you to run commands platform independently, interactively
 if desired, but have them still work.
 .
 The 'can_run' function can tell you if a certain binary is installed and if
 so where, whereas the 'run' function can actually execute any of the
 commands you give it and give you a clear return value, as well as adhere
 to your verbosity settings.

Package: perl-lua-api
Version: 0.04-29.8
Architecture: i386
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 635
Depends: perl-base,liblua5-1-5,libc6
Filename: i386/perl-lua-api_0.04-29.8_i386.deb
Size: 153948
MD5sum: 77da386dd4a9bf6a5e02d701c83dc2dd
SHA1: 6c38159d14e4f7229129d3d2bc0ad1fb0dbb03f7
SHA256: d5b438bd8801df6b0fb580744d235a07c1af71bbfb03db584cb90e8b2e31c906
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/Lua-API
Description: Interface to Lua's embedding API
 *Lua* is a simple, expressive, extension programming language that is
 easily embeddable. *Lua::API* provides Perl bindings to Lua's C-based
 embedding API. It allows Perl routines to be called from Lua as if they
 were written in C, and allows Perl routines to directly manipulate the Lua
 interpreter and its environment. It presents a very low-level interface
 (essentially equivalent to the C interface), so is aimed at developers who
 need that sort of access.
 .
 *Lua::API* is not the first place to turn to if you need a simple, more
 Perl-ish interface; for that, try *Inline::Lua*, which takes a much higher
 level approach and masks most of the underlying complexity in communicating
 between Lua and Perl. Unfortunately by hiding the complexity, this approach
 also prevents full operability. For *Inline::Lua* this is a necessary
 tradeoff, but it does mean that you cannot create as tight an integration
 with Lua.

Package: perl-lua-api
Version: 0.04-29.8
Architecture: amd64
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 759
Depends: perl-base,liblua5-1-5,libc6
Filename: amd64/perl-lua-api_0.04-29.8_amd64.deb
Size: 165316
MD5sum: 588744c6e4879fb78b5fc25f03a1b1ec
SHA1: 9831b0adb7153c13b65d07b0a863b6eeb62469be
SHA256: 5f4d724a5a90023f3ca34baa1e21171ce9488cb9f3dc7b39556272ee34397a6e
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/Lua-API
Description: Interface to Lua's embedding API
 *Lua* is a simple, expressive, extension programming language that is
 easily embeddable. *Lua::API* provides Perl bindings to Lua's C-based
 embedding API. It allows Perl routines to be called from Lua as if they
 were written in C, and allows Perl routines to directly manipulate the Lua
 interpreter and its environment. It presents a very low-level interface
 (essentially equivalent to the C interface), so is aimed at developers who
 need that sort of access.
 .
 *Lua::API* is not the first place to turn to if you need a simple, more
 Perl-ish interface; for that, try *Inline::Lua*, which takes a much higher
 level approach and masks most of the underlying complexity in communicating
 between Lua and Perl. Unfortunately by hiding the complexity, this approach
 also prevents full operability. For *Inline::Lua* this is a necessary
 tradeoff, but it does mean that you cannot create as tight an integration
 with Lua.

Package: perl-module-build
Version: 0.423400-31.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 733
Depends: perl,perl-extutils-cbuilder,perl-base,perl-module-metadata,perl-perl-ostype
Recommends: libextutils-manifest-perl (>= 1.54)
Provides: libmodule-build-perl (= 0.423400-31.1)
Filename: all/perl-module-build_0.423400-31.1_all.deb
Size: 250584
MD5sum: a9c3a6a63bf2fadabc9bef6949d5eb3b
SHA1: a673719a0db93253fe329a22aca84cd8e60ce570
SHA256: f53b48fdedec40f6007f8fb4861f245a77e78d6855490a929cef3c990735aa82
Priority: optional
Homepage: https://metacpan.org/release/Module-Build
Description: Build and install Perl modules
 'Module::Build' is a system for building, testing, and installing Perl
 modules. It is meant to be an alternative to 'ExtUtils::MakeMaker'.
 Developers may alter the behavior of the module through subclassing. It
 also does not require a 'make' on your system - most of the 'Module::Build'
 code is pure-perl and written in a very cross-platform way.
 .
 See "COMPARISON" for more comparisons between 'Module::Build' and other
 installer tools.
 .
 To install 'Module::Build', and any other module that uses 'Module::Build'
 for its installation process, do the following:
 .
   perl Build.PL       # 'Build.PL' script creates the 'Build' script
   ./Build             # Need ./ to ensure we're using this "Build" script
   ./Build test        # and not another one that happens to be in the PATH
   ./Build install
 .
 This illustrates initial configuration and the running of three 'actions'.
 In this case the actions run are 'build' (the default action), 'test', and
 'install'. Other actions defined so far include:
 .
   build                          manifest
   clean                          manifest_skip
   code                           manpages
   config_data                    pardist
   diff                           ppd
   dist                           ppmdist
   distcheck                      prereq_data
   distclean                      prereq_report
   distdir                        pure_install
   distinstall                    realclean
   distmeta                       retest
   distsign                       skipcheck
   disttest                       test
   docs                           testall
   fakeinstall                    testcover
   help                           testdb
   html                           testpod
   install                        testpodcoverage
   installdeps                    versioninstall
 .
 You can run the 'help' action for a complete list of actions.

Package: perl-module-metadata
Version: 1.000038-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 111
Depends: perl
Filename: all/perl-module-metadata_1.000038-27.1_all.deb
Size: 29612
MD5sum: a525953160b5d0a74827eb66fd4cda1b
SHA1: c795b6ea93186d7c2aaae230094cb037a1e00fc9
SHA256: 99ad7203a719ee24761b837d33109fe1447bbca3559bef4b1036b34a1a1741ed
Priority: optional
Homepage: https://metacpan.org/release/Module-Metadata
Description: Gather package and POD information from perl module files
 This module provides a standard way to gather metadata about a .pm file
 through (mostly) static analysis and (some) code execution. When
 determining the version of a module, the '$VERSION' assignment is 'eval'ed,
 as is traditional in the CPAN toolchain.

Package: perl-module-runtime
Version: 0.016-27.5
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 74
Filename: all/perl-module-runtime_0.016-27.5_all.deb
Size: 18356
MD5sum: de686d0c49d86f6b87146eb3c74b0b1e
SHA1: bbc84fe63fc3db52708cd132fc674ec7dc08c34a
SHA256: 6029a2750b19dbb917613f48eb447ae3cd9c24949f9b06da64602cd888a82a38
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Module-Runtime/
Description: Runtime Module Handling
 The functions exported by this module deal with runtime handling of Perl
 modules, which are normally handled at compile time. This module avoids
 using any other modules, so that it can be used in low-level
 infrastructure.
 .
 The parts of this module that work with module names apply the same syntax
 that is used for barewords in Perl source. In principle this syntax can
 vary between versions of Perl, and this module applies the syntax of the
 Perl on which it is running. In practice the usable syntax hasn't changed
 yet. There's some intent for Unicode module names to be supported in the
 future, but this hasn't yet amounted to any consistent facility.
 .
 The functions of this module whose purpose is to load modules include
 workarounds for three old Perl core bugs regarding 'require'. These
 workarounds are applied on any Perl version where the bugs exist, except
 for a case where one of the bugs cannot be adequately worked around in pure
 Perl.

Package: perl-mro-compat
Version: 0.15-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 81
Filename: all/perl-mro-compat_0.15-27.1_all.deb
Size: 17086
MD5sum: 91da4ae7b63499e64078704c08af5ef5
SHA1: b566163a26293a3068becbe1a8d26953875e07da
SHA256: bcbaf41570b4e471905baf2a36d668087a812cfd58c6c96881734e0062e61ed3
Priority: optional
Homepage: https://metacpan.org/release/MRO-Compat
Description: Mro::* interface compatibility for Perls < 5.9.5
 The "mro" namespace provides several utilities for dealing with method
 resolution order and method caching in general in Perl 5.9.5 and higher.
 .
 This module provides those interfaces for earlier versions of Perl (back to
 5.6.0 anyways).
 .
 It is a harmless no-op to use this module on 5.9.5+. That is to say, code
 which properly uses MRO::Compat will work unmodified on both older Perls
 and 5.9.5+.
 .
 If you're writing a piece of software that would like to use the parts of
 5.9.5+'s mro:: interfaces that are supported here, and you want
 compatibility with older Perls, this is the module for you.
 .
 Some parts of this code will work better and/or faster with Class::C3::XS
 installed (which is an optional prereq of Class::C3, which is in turn a
 prereq of this package), but it's not a requirement.
 .
 This module never exports any functions. All calls must be fully qualified
 with the 'mro::' prefix.
 .
 The interface documentation here serves only as a quick reference of what
 the function basically does, and what differences between MRO::Compat and
 5.9.5+ one should look out for. The main docs in 5.9.5's mro are the real
 interface docs, and contain a lot of other useful information.

Package: perl-parent
Version: 0.241-2.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 48
Filename: all/perl-parent_0.241-2.1_all.deb
Size: 8770
MD5sum: f7aeb3cbd54a1e3ab05f5dd7f577d1b6
SHA1: c5ad0a7abbcacf339bff2b788e007e4f299ecfe5
SHA256: ee5d058ce54405f101a7d4e361f1fdaa8fc882b80cf6a6942e057358f7f04fc3
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/parent
Description: Establish an ISA relationship with base classes at compile time
 Allows you to both load one or more modules, while setting up inheritance
 from those modules at the same time. Mostly similar in effect to
 .
     package Baz;
     BEGIN {
         require Foo;
         require Bar;
         push @ISA, qw(Foo Bar);
     }
 .
 By default, every base class needs to live in a file of its own. If you
 want to have a subclass and its parent class in the same file, you can tell
 'parent' not to load any modules by using the '-norequire' switch:
 .
   package Foo;
   sub exclaim { "I CAN HAS PERL" }
 .
   package DoesNotLoadFooBar;
   use parent -norequire, 'Foo', 'Bar';
   # will not go looking for Foo.pm or Bar.pm
 .
 This is equivalent to the following code:
 .
   package Foo;
   sub exclaim { "I CAN HAS PERL" }
 .
   package DoesNotLoadFooBar;
   push @DoesNotLoadFooBar::ISA, 'Foo', 'Bar';
 .
 This is also helpful for the case where a package lives within a
 differently named file:
 .
   package MyHash;
   use Tie::Hash;
   use parent -norequire, 'Tie::StdHash';
 .
 This is equivalent to the following code:
 .
   package MyHash;
   require Tie::Hash;
   push @ISA, 'Tie::StdHash';
 .
 If you want to load a subclass from a file that 'require' would not
 consider an eligible filename (that is, it does not end in either '.pm' or
 '.pmc'), use the following code:
 .
   package MySecondPlugin;
   require './plugins/custom.plugin'; # contains Plugin::Custom
   use parent -norequire, 'Plugin::Custom';

Package: perl-perl-ostype
Version: 1.010-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 74
Filename: all/perl-perl-ostype_1.010-27.1_all.deb
Size: 15134
MD5sum: 0b810e0f907b426e01cdd0adacbc149b
SHA1: cb30004370fbd78bf3d1cb3d88bb0b1bf9896891
SHA256: 69ae57491a9c668544471d60c6a9c5c0711e7722308936969b97dc72590bfe2f
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Perl-OSType/
Description: Map Perl operating system names to generic types
 Modules that provide OS-specific behaviors often need to know if the
 current operating system matches a more generic type of operating systems.
 For example, 'linux' is a type of 'Unix' operating system and so is
 'freebsd'.
 .
 This module provides a mapping between an operating system name as given by
 '$^O' and a more generic type. The initial version is based on the OS type
 mappings provided in Module::Build and ExtUtils::CBuilder. (Thus, Microsoft
 operating systems are given the type 'Windows' rather than 'Win32'.)

Package: perl-pod-coverage
Version: 0.23-29.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 85
Depends: perl-devel-symdump,perl
Filename: all/perl-pod-coverage_0.23-29.1_all.deb
Size: 19036
MD5sum: d8f841685509c32dc5d35446560634af
SHA1: 223dc18ca7da6ad675987978befe60054b147592
SHA256: e3a7b0af8cc27846957bce0abac73a68cd557cc3e137d90d1ed8e94a7c0e2248
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/Pod-Coverage
Description: Checks if the documentation of a module is comprehensive
 Developers hate writing documentation. They'd hate it even more if their
 computer tattled on them, but maybe they'll be even more thankful in the
 long run. Even if not, _perlmodstyle_ tells you to, so you must obey.
 .
 This module provides a mechanism for determining if the pod for a given
 module is comprehensive.
 .
 It expects to find either a '=head(n>1)' or an '=item' block documenting a
 subroutine.
 .
 Consider: # an imaginary Foo.pm package Foo;
 .
  =item foo
 .
  The foo sub
 .
  = cut
 .
  sub foo {}
  sub bar {}
 .
  1;
  __END__
 .
 In this example 'Foo::foo' is covered, but 'Foo::bar' is not, so the 'Foo'
 package is only 50% (0.5) covered

Package: perl-sub-uplevel
Version: 0.2800-26.4
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 112
Filename: all/perl-sub-uplevel_0.2800-26.4_all.deb
Size: 22130
MD5sum: 4e5556a54dac195f4cb2005e1c56358d
SHA1: 427eecdee1ddd1215bfcb3c1a684dd16f266b1dd
SHA256: 33a35b8655a98fd5ac9c7df84300dcfa65135158d01a13199717d0c581e6f58b
Section: Development/Libraries/Perl
Priority: optional
Homepage: https://metacpan.org/release/Sub-Uplevel
Description: Apparently run a function in a higher stack frame
 Like Tcl's uplevel() function, but not quite so dangerous. The idea is
 just to fool caller(). All the really naughty bits of Tcl's uplevel()
 are avoided.

Package: perl-test-class
Version: 0.52-27.10
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 208
Depends: perl-mro-compat,perl-module-runtime,perl,perl-try-tiny
Filename: all/perl-test-class_0.52-27.10_all.deb
Size: 56694
MD5sum: 86f34d1692df368b87f28282e3063eaf
SHA1: 9b8e9de6ab580500b6fb59d853317316887e51fc
SHA256: abb92ab287e7c96130fc97ba84f310e8ac1262ecc6d5c8d4cf61b3a06eedf008
Priority: optional
Homepage: https://metacpan.org/release/Test-Class
Description: Easily create test classes in an xUnit/JUnit style
 Test::Class provides a simple way of creating classes and objects to test
 your code in an xUnit style.
 .
 Built using Test::Builder, it was designed to work with other Test::Builder
 based modules (Test::More, Test::Differences, Test::Exception, etc.).
 .
 _Note:_ This module will make more sense, if you are already familiar with
 the "standard" mechanisms for testing perl code. Those unfamiliar with
 Test::Harness, Test::Simple, Test::More and friends should go take a look
 at them now. Test::Tutorial is a good starting point.

Package: perl-test-compile
Version: 3.3.1-27.4
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 86
Depends: perl-base,perl-parent
Provides: libtest-compile-perl (= 3.3.1-27.4),libtest-compile-internal-perl (= 3.3.1-27.4)
Filename: all/perl-test-compile_3.3.1-27.4_all.deb
Size: 21350
MD5sum: 4b3b16e966cdb24c802b9b5687999fd1
SHA1: fc5d7d184f7788a6eb5b4a90ace93cb24238b5a3
SHA256: e61daff8649bd5e747837bb32baab01b9cc0e6beb2e2efd1051041e9db036da9
Priority: optional
Homepage: https://metacpan.org/release/Test-Compile
Description: Assert that your Perl files compile OK
 'Test::Compile' lets you check the whether your perl modules and scripts
 compile properly, results are reported in standard 'Test::Simple' fashion.
 .
 The basic usage - as shown above, will locate your perl files and test that
 they all compile.
 .
 Module authors can (and probably should) include the following in a
 _t/00-compile.t_ file and have 'Test::Compile' automatically find and check
 all Perl files in a module distribution:
 .
     #!perl
     use strict;
     use warnings;
     use Test::Compile qw();
 .
     my $test = Test::Compile->new();
     $test->all_files_ok();
     $test->done_testing();

Package: perl-test-deep
Version: 1.204-28.2
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 353
Depends: perl
Filename: all/perl-test-deep_1.204-28.2_all.deb
Size: 88206
MD5sum: e794855703efc457e4d16bc5fecc63c7
SHA1: d06e7cce15af883078d9b598040bb1ad05e5d5bf
SHA256: db4a28e408321779132817687cd8c723c8b101993148abe48b036c55d4691076
Priority: optional
Homepage: https://metacpan.org/release/Test-Deep
Description: Extremely flexible deep comparison
 If you don't know anything about automated testing in Perl then you should
 probably read about Test::Simple and Test::More before preceding.
 Test::Deep uses the Test::Builder framework.
 .
 Test::Deep gives you very flexible ways to check that the result you got is
 the result you were expecting. At its simplest it compares two structures
 by going through each level, ensuring that the values match, that arrays
 and hashes have the same elements and that references are blessed into the
 correct class. It also handles circular data structures without getting
 caught in an infinite loop.
 .
 Where it becomes more interesting is in allowing you to do something
 besides simple exact comparisons. With strings, the 'eq' operator checks
 that 2 strings are exactly equal but sometimes that's not what you want.
 When you don't know exactly what the string should be but you do know some
 things about how it should look, 'eq' is no good and you must use pattern
 matching instead. Test::Deep provides pattern matching for complex data
 structures
 .
 Test::Deep has *_a lot_* of exports. See EXPORTS below.

Package: perl-test-differences
Version: 0.710.0-27.2
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 73
Depends: perl-capture-tiny,perl,perl-text-diff
Provides: libtest-differences-perl (= 0.710.0-27.2)
Filename: all/perl-test-differences_0.710.0-27.2_all.deb
Size: 18288
MD5sum: 4edf9911b6d26554e4d9d9890f372b0d
SHA1: 823bc57d51af75e88208ee11ff928de69406f63f
SHA256: 888f2e95d7764bd8ae2703cf1cf59017e6fd8413dda2de959f48b73890d8aca3
Priority: optional
Homepage: https://metacpan.org/release/Test-Differences
Description: Test strings and data structures and show differences if not ok
 When the code you're testing returns multiple lines, records or data
 structures and they're just plain wrong, an equivalent to the Unix 'diff'
 utility may be just what's needed. Here's output from an example test
 script that checks two text documents and then two (trivial) data
 structures:
 .
  t/99example....1..3
  not ok 1 - differences in text
  #     Failed test ((eval 2) at line 14)
  #     +---+----------------+----------------+
  #     | Ln|Got             |Expected        |
  #     +---+----------------+----------------+
  #     |  1|this is line 1  |this is line 1  |
  #     *  2|this is line 2  |this is line b  *
  #     |  3|this is line 3  |this is line 3  |
  #     +---+----------------+----------------+
  not ok 2 - differences in whitespace
  #     Failed test ((eval 2) at line 20)
  #     +---+------------------+------------------+
  #     | Ln|Got               |Expected          |
  #     +---+------------------+------------------+
  #     |  1|        indented  |        indented  |
  #     *  2|        indented  |\tindented        *
  #     |  3|        indented  |        indented  |
  #     +---+------------------+------------------+
  not ok 3
  #     Failed test ((eval 2) at line 22)
  #     +----+-------------------------------------+----------------------------+
  #     | Elt|Got                                  |Expected                    |
  #     +----+-------------------------------------+----------------------------+
  #     *   0|bless( [                             |[                           *
  #     *   1|  'Move along, nothing to see here'  |  'Dry, humorless message'  *
  #     *   2|], 'Test::Builder' )                 |]                           *
  #     +----+-------------------------------------+----------------------------+
  # Looks like you failed 3 tests of 3.
 .
 eq_or_diff_...() compares two strings or (limited) data structures and
 either emits an ok indication or a side-by-side diff. Test::Differences is
 designed to be used with Test.pm and with Test::Simple, Test::More, and
 other Test::Builder based testing modules. As the SYNOPSIS shows, another
 testing module must be used as the basis for your test suite.

Package: perl-test-exception
Version: 0.430000-27.7
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 71
Depends: perl-sub-uplevel,perl
Provides: libtest-exception-perl (= 0.430000-27.7)
Filename: all/perl-test-exception_0.430000-27.7_all.deb
Size: 17980
MD5sum: 3aea3beac522b1354f274191f1434546
SHA1: 2d2f27f54b6293e7dfab1877951d178165820e80
SHA256: dbcfbeba319325ac2bb0300c82ecf1547212c65732d75dd89b58d45569b35a93
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Test-Exception/
Description: Test exception-based code
 This module provides a few convenience methods for testing exception based
 code. It is built with Test::Builder and plays happily with Test::More and
 friends.
 .
 If you are not already familiar with Test::More now would be the time to go
 take a look.
 .
 You can specify the test plan when you 'use Test::Exception' in the same
 way as 'use Test::More'. See Test::More for details.
 .
 NOTE: Test::Exception only checks for exceptions. It will ignore other
 methods of stopping program execution - including exit(). If you have an
 exit() in evalled code Test::Exception will not catch this with any of its
 testing functions.
 .
 NOTE: This module uses Sub::Uplevel and relies on overriding
 'CORE::GLOBAL::caller' to hide your test blocks from the call stack. If
 this use of global overrides concerns you, the Test::Fatal module offers a
 more minimalist alternative.
 .
 * *throws_ok*
 .
 Tests to see that a specific exception is thrown. throws_ok() has two
 forms:
 .
   throws_ok BLOCK REGEX, TEST_DESCRIPTION
   throws_ok BLOCK CLASS, TEST_DESCRIPTION
 .
 In the first form the test passes if the stringified exception matches the
 give regular expression. For example:
 .
     throws_ok { read_file( 'unreadable' ) } qr/No file/, 'no file';
 .
 If your perl does not support 'qr//' you can also pass a regex-like string,
 for example:
 .
     throws_ok { read_file( 'unreadable' ) } '/No file/', 'no file';
 .
 The second form of throws_ok() test passes if the exception is of the same
 class as the one supplied, or a subclass of that class. For example:
 .
     throws_ok { $foo->bar } "Error::Simple", 'simple error';
 .
 Will only pass if the 'bar' method throws an Error::Simple exception, or a
 subclass of an Error::Simple exception.
 .
 You can get the same effect by passing an instance of the exception you
 want to look for. The following is equivalent to the previous example:
 .
     my $SIMPLE = Error::Simple->new;
     throws_ok { $foo->bar } $SIMPLE, 'simple error';
 .
 Should a throws_ok() test fail it produces appropriate diagnostic messages.
 For example:
 .
     not ok 3 - simple error
     #     Failed test (test.t at line 48)
     # expecting: Error::Simple exception
     # found: normal exit
 .
 Like all other Test::Exception functions you can avoid prototypes by
 passing a subroutine explicitly:
 .
     throws_ok( sub {$foo->bar}, "Error::Simple", 'simple error' );
 .
 A true value is returned if the test succeeds, false otherwise. On exit $@
 is guaranteed to be the cause of death (if any).
 .
 A description of the exception being checked is used if no optional test
 description is passed.
 .
 NOTE: Remember when you 'die $string_without_a_trailing_newline' perl will
 automatically add the current script line number, input line number and a
 newline. This will form part of the string that throws_ok regular
 expressions match against.
 .
 * *dies_ok*
 .
 Checks that a piece of code dies, rather than returning normally. For
 example:
 .
     sub div {
         my ( $a, $b ) = @_;
         return $a / $b;
     };
 .
     dies_ok { div( 1, 0 ) } 'divide by zero detected';
 .
     # or if you don't like prototypes
     dies_ok( sub { div( 1, 0 ) }, 'divide by zero detected' );
 .
 A true value is returned if the test succeeds, false otherwise. On exit $@
 is guaranteed to be the cause of death (if any).
 .
 Remember: This test will pass if the code dies for any reason. If you care
 about the reason it might be more sensible to write a more specific test
 using throws_ok().
 .
 The test description is optional, but recommended.
 .
 * *lives_ok*
 .
 Checks that a piece of code doesn't die. This allows your test script to
 continue, rather than aborting if you get an unexpected exception. For
 example:
 .
     sub read_file {
         my $file = shift;
         local $/;
         open my $fh, '<', $file or die "open failed ($!)\n";
         $file = <FILE>;
         return $file;
     };
 .
     my $file;
     lives_ok { $file = read_file('test.txt') } 'file read';
 .
     # or if you don't like prototypes
     lives_ok( sub { $file = read_file('test.txt') }, 'file read' );
 .
 Should a lives_ok() test fail it produces appropriate diagnostic messages.
 For example:
 .
     not ok 1 - file read
     #     Failed test (test.t at line 15)
     # died: open failed (No such file or directory)
 .
 A true value is returned if the test succeeds, false otherwise. On exit $@
 is guaranteed to be the cause of death (if any).
 .
 The test description is optional, but recommended.
 .
 * *lives_and*
 .
 Run a test that may throw an exception. For example, instead of doing:
 .
   my $file;
   lives_ok { $file = read_file('answer.txt') } 'read_file worked';
   is $file, "42", 'answer was 42';
 .
 You can use lives_and() like this:
 .
   lives_and { is read_file('answer.txt'), "42" } 'answer is 42';
   # or if you don't like prototypes
   lives_and(sub {is read_file('answer.txt'), "42"}, 'answer is 42');
 .
 Which is the same as doing
 .
   is read_file('answer.txt'), "42\n", 'answer is 42';
 .
 unless 'read_file('answer.txt')' dies, in which case you get the same kind
 of error as lives_ok()
 .
   not ok 1 - answer is 42
   #     Failed test (test.t at line 15)
   # died: open failed (No such file or directory)
 .
 A true value is returned if the test succeeds, false otherwise. On exit $@
 is guaranteed to be the cause of death (if any).
 .
 The test description is optional, but recommended.

Package: perl-test-most
Version: 0.38-27.11
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 87
Depends: perl-exception-class,perl-test-deep,perl-test-differences,perl-test-exception,perl,perl-test-warn
Filename: all/perl-test-most_0.38-27.11_all.deb
Size: 23256
MD5sum: 7b21c7be17cd3dbaca1a71fcdc7518da
SHA1: 0d398b653500d482c04f6ce933f81d26f0447933
SHA256: aa4b8e10a501896284cb10c0589c4d8a9857a386794fbb752e29f4865c8e9d6b
Priority: optional
Homepage: https://metacpan.org/release/Test-Most
Description: Most commonly needed test functions and features
 Test::Most exists to reduce boilerplate and to make your testing life
 easier. We provide "one stop shopping" for most commonly used testing
 modules. In fact, we often require the latest versions so that you get bug
 fixes through Test::Most and don't have to keep upgrading these modules
 separately.
 .
 This module provides you with the most commonly used testing functions,
 along with automatically turning on strict and warning and gives you a bit
 more fine-grained control over your test suite.
 .
     use Test::Most tests => 4, 'die';
 .
     ok 1, 'Normal calls to ok() should succeed';
     is 2, 2, '... as should all passing tests';
     eq_or_diff [3], [4], '... but failing tests should die';
     ok 4, '... will never get to here';
 .
 As you can see, the 'eq_or_diff' test will fail. Because 'die' is in the
 import list, the test program will halt at that point.
 .
 If you do not want strict and warnings enabled, you must explicitly disable
 them. Thus, you must be explicit about what you want and no longer need to
 worry about accidentally forgetting them.
 .
     use Test::Most tests => 4;
     no strict;
     no warnings;

Package: perl-test-pod
Version: 1.52-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 62
Depends: perl
Filename: all/perl-test-pod_1.52-27.1_all.deb
Size: 13244
MD5sum: 5d67ec407e3e53b45f7387269852eb20
SHA1: 3cbab590828c929ca41c7a0ffc925e97a08bab4a
SHA256: cff40bc4a2536d19fc285c81750e96e9d4a2fb909d231a65f35bcecdb1966362
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Test-Pod/
Description: Check for Pod Errors in Files
 Check POD files for errors or warnings in a test file, using 'Pod::Simple'
 to do the heavy lifting.

Package: perl-test-pod-coverage
Version: 1.10-28.2
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 61
Depends: perl-pod-coverage
Filename: all/perl-test-pod-coverage_1.10-28.2_all.deb
Size: 10856
MD5sum: 2227aa3626ff533bf226b988b5176eb9
SHA1: 8c6a1ec1a80c2697afde79a56f1ab0237db1ab3b
SHA256: c49b8cb72f9bc17c291c75abb654d1a920e698f0aed67d4c74893b6cf95deee5
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Test-Pod-Coverage/
Description: Check for pod coverage in your distribution.
 Test::Pod::Coverage is used to create a test for your distribution, to
 ensure that all relevant files in your distribution are appropriately
 documented in pod.
 .
 Can also be called with the Pod::Coverage manpage parms.
 .
     use Test::Pod::Coverage tests=>1;
     pod_coverage_ok(
         "Foo::Bar",
         { also_private => [ qr/^[A-Z_]+$/ ], },
         "Foo::Bar, with all-caps functions as privates",
     );
 .
 The the Pod::Coverage manpage parms are also useful for subclasses that
 don't re-document the parent class's methods. Here's an example from the
 Mail::SRS manpage.
 .
     pod_coverage_ok( "Mail::SRS" ); # No exceptions
 .
     # Define the three overridden methods.
     my $trustme = { trustme => [qr/^(new|parse|compile)$/] };
     pod_coverage_ok( "Mail::SRS::DB", $trustme );
     pod_coverage_ok( "Mail::SRS::Guarded", $trustme );
     pod_coverage_ok( "Mail::SRS::Reversable", $trustme );
     pod_coverage_ok( "Mail::SRS::Shortcut", $trustme );
 .
 Alternately, you could use the Pod::Coverage::CountParents manpage, which
 always allows a subclass to reimplement its parents' methods without
 redocumenting them. For example:
 .
     my $trustparents = { coverage_class => 'Pod::Coverage::CountParents' };
     pod_coverage_ok( "IO::Handle::Frayed", $trustparents );
 .
 (The 'coverage_class' parameter is not passed to the coverage class with
 other parameters.)
 .
 If you want POD coverage for your module, but don't want to make
 Test::Pod::Coverage a prerequisite for installing, create the following as
 your _t/pod-coverage.t_ file:
 .
     use Test::More;
     eval "use Test::Pod::Coverage";
     plan skip_all => "Test::Pod::Coverage required for testing pod coverage" if $@;
 .
     plan tests => 1;
     pod_coverage_ok( "Pod::Master::Html");
 .
 Finally, Module authors can include the following in a _t/pod-coverage.t_
 file and have 'Test::Pod::Coverage' automatically find and check all
 modules in the module distribution:
 .
     use Test::More;
     eval "use Test::Pod::Coverage 1.00";
     plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD coverage" if $@;
     all_pod_coverage_ok();

Package: perl-test-warn
Version: 0.37-27.6
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 70
Depends: perl-carp,perl-sub-uplevel
Filename: all/perl-test-warn_0.37-27.6_all.deb
Size: 14726
MD5sum: ef2d21ddee464c3bec6a58e4f7e7695c
SHA1: 001f13650096bbafff698c4bdebcd6bcdd8b39ba
SHA256: 1d27edb27155bc6095eed47b1531deddebf565012c6ef449a7ebee1e80d2d3eb
Priority: optional
Homepage: https://metacpan.org/release/Test-Warn
Description: Perl extension to test methods for warnings
 A good style of Perl programming calls for a lot of diverse regression
 tests.
 .
 This module provides a few convenience methods for testing warning
 based-code.
 .
 If you are not already familiar with the Test::More manpage now would be
 the time to go take a look.

Package: perl-text-diff
Version: 1.45-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 129
Depends: libalgorithm-diff-perl
Filename: all/perl-text-diff_1.45-27.1_all.deb
Size: 33338
MD5sum: 4e5ef7b6f74947d94b393d3eba89c867
SHA1: 5e696f4b04ff822ad107fb2dd9c90b5e58c3fa10
SHA256: 942cdd2a144279c20dcda362b13efd0fe0fb1b4b473f48eb9aab03243ac4720e
Section: Development/Libraries/Perl
Priority: optional
Homepage: http://search.cpan.org/dist/Text-Diff/
Description: Perform diffs on files and record sets
 'diff()' provides a basic set of services akin to the GNU 'diff' utility.
 It is not anywhere near as feature complete as GNU 'diff', but it is better
 integrated with Perl and available on all platforms. It is often faster
 than shelling out to a system's 'diff' executable for small files, and
 generally slower on larger files.
 .
 Relies on Algorithm::Diff for, well, the algorithm. This may not produce
 the same exact diff as a system's local 'diff' executable, but it will be a
 valid diff and comprehensible by 'patch'. We haven't seen any differences
 between Algorithm::Diff's logic and GNU 'diff''s, but we have not examined
 them to make sure they are indeed identical.
 .
 *Note*: If you don't want to import the 'diff' function, do one of the
 following:
 .
    use Text::Diff ();
 .
    require Text::Diff;
 .
 That's a pretty rare occurrence, so 'diff()' is exported by default.
 .
 If you pass a filename, but the file can't be read, then 'diff()' will
 'croak'.

Package: perl-try-tiny
Version: 0.31-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 80
Filename: all/perl-try-tiny_0.31-27.1_all.deb
Size: 23848
MD5sum: 3ca5f8e446b84a72b76e44520153a49e
SHA1: d5278eda77d896664fba2320e7ffef3a23b4bc56
SHA256: 5eed12ca06f05db2d6cf0c8d272d81954699fb42c8957b00ff3d961dbe2c383e
Priority: optional
Homepage: https://metacpan.org/release/Try-Tiny
Description: Minimal try/catch with proper preservation of $@
 This module provides bare bones 'try'/'catch'/'finally' statements that are
 designed to minimize common mistakes with eval blocks, and NOTHING else.
 .
 This is unlike TryCatch which provides a nice syntax and avoids adding
 another call stack layer, and supports calling 'return' from the 'try'
 block to return from the parent subroutine. These extra features come at a
 cost of a few dependencies, namely Devel::Declare and Scope::Upper which
 are occasionally problematic, and the additional catch filtering uses Moose
 type constraints which may not be desirable either.
 .
 The main focus of this module is to provide simple and reliable error
 handling for those having a hard time installing TryCatch, but who still
 want to write correct 'eval' blocks without 5 lines of boilerplate each
 time.
 .
 It's designed to work as correctly as possible in light of the various
 pathological edge cases (see BACKGROUND) and to be compatible with any
 style of error values (simple strings, references, objects, overloaded
 objects, etc).
 .
 If the 'try' block dies, it returns the value of the last statement
 executed in the 'catch' block, if there is one. Otherwise, it returns
 'undef' in scalar context or the empty list in list context. The following
 examples all assign '"bar"' to '$x':
 .
   my $x = try { die "foo" } catch { "bar" };
   my $x = try { die "foo" } || "bar";
   my $x = (try { die "foo" }) // "bar";
 .
   my $x = eval { die "foo" } || "bar";
 .
 You can add 'finally' blocks, yielding the following:
 .
   my $x;
   try { die 'foo' } finally { $x = 'bar' };
   try { die 'foo' } catch { warn "Got a die: $_" } finally { $x = 'bar' };
 .
 'finally' blocks are always executed making them suitable for cleanup code
 which cannot be handled using local. You can add as many 'finally' blocks
 to a given 'try' block as you like.
 .
 Note that adding a 'finally' block without a preceding 'catch' block
 suppresses any errors. This behaviour is consistent with using a standalone
 'eval', but it is not consistent with 'try'/'finally' patterns found in
 other programming languages, such as Java, Python, Javascript or C#. If you
 learned the 'try'/'finally' pattern from one of these languages, watch out
 for this.

Package: perl-universal-require
Version: 0.19-27.1
Architecture: all
Maintainer: Uyuni packagers <devel@lists.uyuni-project.org>
Installed-Size: 52
Filename: all/perl-universal-require_0.19-27.1_all.deb
Size: 8842
MD5sum: 0f9dabc342d95fae89b63f2ce55c5daf
SHA1: 3c779f92276f8a6f0fbb8af49c736c0375b93994
SHA256: 8033fc2f3f02ad78705fc2dead128437817e2c695cfeec62fe566902e05d184f
Priority: optional
Homepage: https://metacpan.org/release/UNIVERSAL-require
Description: Require() modules from a variable [deprecated]
 Before using this module, you should look at the alternatives, some of
 which are listed in SEE ALSO below.
 .
 This module provides a safe mechanism for loading a module at runtime, when
 you have the name of the module in a variable.
 .
 If you've ever had to do this...
 .
     eval "require $module";
 .
 to get around the bareword caveats on require(), this module is for you. It
 creates a universal require() class method that will work with every Perl
 module and its secure. So instead of doing some arcane eval() work, you can
 do this:
 .
     $module->require;
 .
 It doesn't save you much typing, but it'll make a lot more sense to someone
 who's not a ninth level Perl acolyte.

