Package: deb-perl-macros Version: 0.1-2.6 Architecture: all Maintainer: Victor Zhestkov Installed-Size: 42 Depends: perl Filename: all/deb-perl-macros_0.1-2.6_all.deb Size: 2700 MD5sum: 9ac0d969fda7e3e4469272e341d28dfb SHA1: bd394b2b176bd38e1fa90a0f38c6d20a46ef123c SHA256: b1f5e6fc308a57a8e17c74cd04e48db927a3b10ad20fe7706c1f9b92f026c236 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.09.0-2.1 Architecture: all Maintainer: debbuild developers 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.09.0-2.1_all.deb Size: 54948 MD5sum: f4dbce538e7fa9bdc2061f9e440610aa SHA1: 2f0f02713cfc93a0549a554bb6ff0ee34ec8a8c1 SHA256: 068740a6157ad405fb09b9ea6e4140fc55affb9dc4c309d6f7e2d3228e1bbfdd 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.09.0-2.1 Architecture: all Maintainer: debbuild developers Installed-Size: 32 Depends: debbuild (= 24.09.0-2.1),liblua-api-perl Filename: all/debbuild-lua-support_24.09.0-2.1_all.deb Size: 8504 MD5sum: 38ec743df7fb2fe00b220c27b5ae1a16 SHA1: 5bb8dab35119fa6dde881859c32f3fa86059f665 SHA256: b298469883d581e7976eb6991313992f4a6f0e24c1e2ba89352549b20abd12c6 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.7-2.2 Architecture: all Maintainer: debbuild developers 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.7-2.2_all.deb Size: 25500 MD5sum: 8dd1b3d5786cdbadab84c2732d97ba51 SHA1: 1c22c4108fc76b0f307c1fdda9915b76a0c694f4 SHA256: f57eb19cdb5c67fa58127d069f62e7c69e3beb637e30dea02d73b99f08a1a19e 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-45.17 Architecture: ppc64el Maintainer: Uyuni packagers Installed-Size: 401 Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-45.17) Provides: lua51-libs (= 5.1.5-45.17),liblua5-1 (= 5.1.5-45.17) Filename: ppc64el/liblua5-1-5_5.1.5-45.17_ppc64el.deb Size: 77032 MD5sum: 98d65cdb2528b79a4203e573c71d82bc SHA1: 4ea0d2f49741fcd8415f5d2fb67b846b6418b89d SHA256: 994ee1cc794620d4e36047be612a7867d9971d8ec9aff249db2395ab4eefb800 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-45.17 Architecture: armhf Maintainer: Uyuni packagers Installed-Size: 840 Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-45.17) Provides: lua51-libs (= 5.1.5-45.17),liblua5-1 (= 5.1.5-45.17) Filename: armhf/liblua5-1-5_5.1.5-45.17_armhf.deb Size: 277884 MD5sum: bc902173a51d3e8caadd0ae181cba917 SHA1: 20f2a8fb8a1c340f7b6ac41813cec93d8e8fca59 SHA256: 805903763130ecc39e337450323dceb16bd501be456161ba91740b1308b7dde0 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-45.17 Architecture: arm64 Maintainer: Uyuni packagers Installed-Size: 1124 Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-45.17) Provides: lua51-libs (= 5.1.5-45.17),liblua5-1 (= 5.1.5-45.17) Filename: arm64/liblua5-1-5_5.1.5-45.17_arm64.deb Size: 293160 MD5sum: 361937cdf83fa136b36341cbca05146b SHA1: 36e5e917c8cba29ba5a7578bebacb32d0054cd2c SHA256: 8df3230abe19057909211e15192b3a5a41863e4bfbbc2c3aa955bf191119ffa1 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-45.17 Architecture: amd64 Maintainer: Uyuni packagers Installed-Size: 1103 Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-45.17) Provides: lua51-libs (= 5.1.5-45.17),liblua5-1 (= 5.1.5-45.17) Filename: amd64/liblua5-1-5_5.1.5-45.17_amd64.deb Size: 305148 MD5sum: e981c8959d3ab95613a21fcfd78a63aa SHA1: 10619b55258f4bd850fd917966a433fbbf34e716 SHA256: 522adb7e116508a857e2765f1f47a6c3cbc36b0a7f0c20d4bd47ae079634852f 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-45.17 Architecture: i386 Maintainer: Uyuni packagers Installed-Size: 885 Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-45.17) Provides: lua51-libs (= 5.1.5-45.17),liblua5-1 (= 5.1.5-45.17) Filename: i386/liblua5-1-5_5.1.5-45.17_i386.deb Size: 299800 MD5sum: e37a9f154a552292f9cca7117659baa7 SHA1: 2139a2a308e1ce96160db21fdd6c271490c55b90 SHA256: 6e3be3c393566ed2a9b9043c01fa82da6c654de9e0a607aea04f196dc89a2801 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-45.17 Architecture: s390x Maintainer: Uyuni packagers Installed-Size: 359 Replaces: lua51-libs (<< 5.1.5),liblua5-1 (<< 5.1.5-45.17) Provides: lua51-libs (= 5.1.5-45.17),liblua5-1 (= 5.1.5-45.17) Filename: s390x/liblua5-1-5_5.1.5-45.17_s390x.deb Size: 74648 MD5sum: 0a86daa378be06af7a8036ca2ccacd49 SHA1: 2e5de3758a9db8dfcf063b12dde369062569328b SHA256: f157e791e41233e424fe9ca40908a4e96967260e913fea7fcd5f3204609a9e67 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-28.2 Architecture: all Maintainer: Uyuni packagers Installed-Size: 25 Filename: all/lua-macros_20210827-28.2_all.deb Size: 1572 MD5sum: 19d7d6f95cf1d3b4ac91815a6d0e244b SHA1: fb74e583a310ade5a5fbe4b20da4db03a137c22f SHA256: 7b61f9bbb43b7e14f2ce82088b3b1db00533392838c2e6f6f5cee49eee9e8e63 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-45.17 Architecture: ppc64el Maintainer: Uyuni packagers Installed-Size: 645 Depends: dpkg,libreadline8,libc6,libtinfo6 Provides: lua (= 5.1.5-45.17),lua-api (= 5.1) Filename: ppc64el/lua51_5.1.5-45.17_ppc64el.deb Size: 93020 MD5sum: 8f971e71e6e7c6b3b0c804262f908dd9 SHA1: 1e2b2f0ab5e1d9513213e048937296ce739dfa8a SHA256: 3e0bc30032c4bb19e862a982f940466be7f606c2c223d328bdf5a5293aa7c458 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-45.17 Architecture: armhf Maintainer: Uyuni packagers Installed-Size: 1490 Depends: dpkg,libreadline8,libc6,libtinfo6 Provides: lua (= 5.1.5-45.17),lua-api (= 5.1) Filename: armhf/lua51_5.1.5-45.17_armhf.deb Size: 338712 MD5sum: 6c194a4fd202d2c0a670dced8cefec66 SHA1: b89ec4062e8f4f099a5121f510c65a5276128d1b SHA256: c486e9662331dea5b366b28359e09913231d0c10dad6fc83f8ca06e5822c0045 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-45.17 Architecture: arm64 Maintainer: Uyuni packagers Installed-Size: 1985 Depends: dpkg,libc6,libreadline8,libtinfo6 Provides: lua (= 5.1.5-45.17),lua-api (= 5.1) Filename: arm64/lua51_5.1.5-45.17_arm64.deb Size: 356652 MD5sum: 18648f41ca8e6a8e9b2c6419a45d68ce SHA1: c36125577fc7cfae748a82b9715c6d44845a3a19 SHA256: c611ebd78f5567e9cf21db2f9b7e89f70b9ecc567db701deb7a46c0f7a7be58b 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-45.17 Architecture: amd64 Maintainer: Uyuni packagers Installed-Size: 1942 Depends: dpkg,libreadline8,libc6,libtinfo6 Provides: lua (= 5.1.5-45.17),lua-api (= 5.1) Filename: amd64/lua51_5.1.5-45.17_amd64.deb Size: 384752 MD5sum: 5aa9673d9c825de19a1a86062181c158 SHA1: 53ab761548c35af06b45ca801359915cdee29bb1 SHA256: 4b0064935b3bce7e1674fab9fc4ae35cbc8c4ad82e2a4416beede95e0c03acc8 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-45.17 Architecture: i386 Maintainer: Uyuni packagers Installed-Size: 1558 Depends: dpkg,libreadline8,libc6,libtinfo6 Provides: lua (= 5.1.5-45.17),lua-api (= 5.1) Filename: i386/lua51_5.1.5-45.17_i386.deb Size: 376444 MD5sum: 779057173d586f8b95b7dfcba68c01f4 SHA1: ce634df07b97f631eeaea0552d8e3bfa7f40f820 SHA256: 8df764342ac6a35cbf028103e261b35f413a0e0992b18c8b0775ae6a489a7f02 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-45.17 Architecture: s390x Maintainer: Uyuni packagers Installed-Size: 604 Depends: dpkg,libreadline8,libc6,libtinfo6 Provides: lua (= 5.1.5-45.17),lua-api (= 5.1) Filename: s390x/lua51_5.1.5-45.17_s390x.deb Size: 90140 MD5sum: 0535720cc7381cc4cf6af8e703e70cff SHA1: 060bd44bce14946682c06f8c9f5d7e67495d9080 SHA256: 984914024dd949aacd97117d6b533fa4398f7410c8b57700c7ae9b8256a51e2d 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-45.17 Architecture: ppc64el Maintainer: Uyuni packagers Installed-Size: 586 Depends: liblua5-1-5 (= 5.1.5-45.17),lua51 (= 5.1.5-45.17),lua-macros,dpkg Provides: lua-devel (= 5.1.5-45.17),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-45.17) Filename: ppc64el/lua51-devel_5.1.5-45.17_ppc64el.deb Size: 93272 MD5sum: 292e9d7482eeae952d6880a009e7ae63 SHA1: 985d7950f407f5e58aa513d9afb6dc2811b502a9 SHA256: af4ea95dd2060d93ead02a1281d8014ae7231d143adfb686f1163b1ffcad53b8 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-45.17 Architecture: armhf Maintainer: Uyuni packagers Installed-Size: 1206 Depends: liblua5-1-5 (= 5.1.5-45.17),lua51 (= 5.1.5-45.17),lua-macros,dpkg Provides: lua-devel (= 5.1.5-45.17),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-45.17) Filename: armhf/lua51-devel_5.1.5-45.17_armhf.deb Size: 354736 MD5sum: af01e1ce60557abe2fb349d03802a652 SHA1: 0f33ec31f6e1c166b14200af588e1677526ddf39 SHA256: aac7a5c7f6477c6d7ff9b607315e94b6385db653601b5e47d5e3c59155f238e0 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-45.17 Architecture: arm64 Maintainer: Uyuni packagers Installed-Size: 1919 Depends: liblua5-1-5 (= 5.1.5-45.17),lua51 (= 5.1.5-45.17),lua-macros,dpkg Provides: lua-devel (= 5.1.5-45.17),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-45.17) Filename: arm64/lua51-devel_5.1.5-45.17_arm64.deb Size: 370248 MD5sum: dc01ddbefc116b21f94b336b9495559c SHA1: 57f92833318d0f62836cabdb6f6c7f186270c94a SHA256: 645244f91cfc7724a5141d7ad83ff59f9e1448515593b1dd80894d4a0581c99f 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-45.17 Architecture: amd64 Maintainer: Uyuni packagers Installed-Size: 2121 Depends: liblua5-1-5 (= 5.1.5-45.17),lua51 (= 5.1.5-45.17),lua-macros,dpkg Provides: lua-devel (= 5.1.5-45.17),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-45.17) Filename: amd64/lua51-devel_5.1.5-45.17_amd64.deb Size: 387740 MD5sum: 34c44609fe134c8fc70847c51b32b6f1 SHA1: 7718e38391862a7922f99388ba54084c36b986ce SHA256: c599d1415914527f7c854e7025c9719eeedef135cb0a18d9152746d7def0e3e9 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-45.17 Architecture: i386 Maintainer: Uyuni packagers Installed-Size: 1320 Depends: liblua5-1-5 (= 5.1.5-45.17),lua51 (= 5.1.5-45.17),lua-macros,dpkg Provides: lua-devel (= 5.1.5-45.17),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-45.17) Filename: i386/lua51-devel_5.1.5-45.17_i386.deb Size: 380656 MD5sum: e92728c0f32eb2fb28ced8e469713745 SHA1: c6f98ee21e4cf90f6da6d7dbd57e40267a8ac677 SHA256: 00201d015642ddb41f774a199a7f8c1daa8a85cb5cddce73fbd81cd08a6bfeed 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-45.17 Architecture: s390x Maintainer: Uyuni packagers Installed-Size: 541 Depends: liblua5-1-5 (= 5.1.5-45.17),lua51 (= 5.1.5-45.17),lua-macros,dpkg Provides: lua-devel (= 5.1.5-45.17),lua-devel (= 5.1),pkgconfig-lua (= 5.1.5-45.17) Filename: s390x/lua51-devel_5.1.5-45.17_s390x.deb Size: 90156 MD5sum: f39a2fec991c383490648fdbd125b61e SHA1: 1531d78a3339476c275b47db02542c3a03305cf8 SHA256: 5d8ab772da2024fca4567f0dd2bc2c1387733535af69c02f05289ce4095d8a49 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-45.17 Architecture: all Maintainer: Uyuni packagers Installed-Size: 330 Filename: all/lua51-doc_5.1.5-45.17_all.deb Size: 71676 MD5sum: 75e45ab66cd2753624d07d1bf9f08b21 SHA1: cbd4ea4f9798a65528ac153fea60d9760ec3732c SHA256: c56a427aa47fc15d15fc6bf046f8934e6e3c52f20a81093412eaac3fe29aa96b 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 121 Filename: all/perl-capture-tiny_0.48-3.5_all.deb Size: 29988 MD5sum: 0c5b2fc02941c34be527d9d9383fcfcf SHA1: dcbee346771296d1e3b42cb4e4a4aff2a8326907 SHA256: 74f53e92440a17bf3f12ba1e3f68be9d77469ebfc9f30f3716d5bcdf7049b0d3 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-3.6 Architecture: all Maintainer: Uyuni packagers Installed-Size: 88 Filename: all/perl-carp_1.50-3.6_all.deb Size: 22668 MD5sum: 433aed6f8b811c27f49e2d6a531b930c SHA1: 8b4e4049988079de5821ede8c7867da9727ac6d3 SHA256: 8f2fc2c6b2ad750ac19bdb958c19a2376d77b0bc465bf30bc0b0d72c03be3bfc 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 55 Filename: all/perl-class-data-inheritable_0.09-3.5_all.deb Size: 7232 MD5sum: a3c54edcfb9913bce3d5db3cf580c0dd SHA1: de8bded121df42f25c018e2627f68a7131c95217 SHA256: e23b7dfc4f8b7be7d8c30bba12d4fa4e994d1a3c6c89b8cd425219538eec1c65 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 113 Filename: all/perl-devel-stacktrace_2.04-3.5_all.deb Size: 28404 MD5sum: a873ccc81682075218eb4e9adf2e55f0 SHA1: 24c56f805c92c9c9a331893df783e56635773dc1 SHA256: c48dfdae28284f4dbae0dd210709796ffcb7e8ecbb6f6947b60021cfc3a4ee2c 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 76 Depends: perl Filename: all/perl-devel-symdump_2.18-3.5_all.deb Size: 14364 MD5sum: 866c04f0791ab26e20a1760ab986cfba SHA1: f662ecda5a2b89f04df493223ac898667b31318f SHA256: 6df970d81a7f5d1e24f6fbc54ca4a3d6639418c7bff3315c773579886139b9c5 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-3.14 Architecture: all Maintainer: Uyuni packagers Installed-Size: 142 Depends: perl-class-data-inheritable,perl-devel-stacktrace Filename: all/perl-exception-class_1.45-3.14_all.deb Size: 39048 MD5sum: 6996c5b49e56cde4eeb2a496585b7200 SHA1: ae86f5fd1b81668ca656ceb49b63af119dc13029 SHA256: a4dfbb3b3d318a103c53e0546f680999b1cc165a3e5fa29e48a58d037560be39 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-2.16 Architecture: all Maintainer: Uyuni packagers Installed-Size: 155 Depends: perl,perl-ipc-cmd,perl-perl-ostype Filename: all/perl-extutils-cbuilder_0.280236-2.16_all.deb Size: 39260 MD5sum: b16352d9bc83a982f6527722ff5aacbb SHA1: 7bd973c30f96c3042804f0f86ed7fe0ce3981a83 SHA256: d750dce04dced11c4cb32e2030dd1cbb9976e432e8deec341c36b66fcecfb02f 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-4.6 Architecture: all Maintainer: Uyuni packagers Installed-Size: 890 Filename: all/perl-extutils-makemaker_7.66-4.6_all.deb Size: 304284 MD5sum: 40a6f99c75f4c972e476728690c940ae SHA1: ee54aedf6aa5a021569819673ebcf44e1934f3cd SHA256: af03d96b4fa3bba395de904a1b6f77b6c9394cd02c442dd052295426442af979 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 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 for details of the design and usage. Package: perl-extutils-pkgconfig Version: 1.160000-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 61 Depends: pkg-config Provides: libextutils-pkgconfig-perl (= 1.160000-3.5) Filename: all/perl-extutils-pkgconfig_1.160000-3.5_all.deb Size: 10548 MD5sum: 9b49b1b3bc16fa61c583210fd8fd8f8e SHA1: bb2a50d8fe9091dfbdf225407368e493e306b272 SHA256: 98f28979cec959218a52e1d68215b1be23a373c0194bc98275eb368a82d2abd1 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 107 Provides: libfile-path-perl (= 2.180000-3.5) Filename: all/perl-file-path_2.180000-3.5_all.deb Size: 30668 MD5sum: 840eeceb346a1c102e29b595b197d2ce SHA1: b8bbd967d24988781648c4461d2001666ce369c1 SHA256: 00c93c459391e002b4a545ae12a9e1b2f5b6f2676205eae5d4f86bb74d3007f7 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-3.9 Architecture: all Maintainer: Uyuni packagers Installed-Size: 207 Depends: perl-file-path,perl-parent Filename: all/perl-file-temp_0.2311-3.9_all.deb Size: 53280 MD5sum: b7fc9ec458f71182c0d2a5ebd52a5674 SHA1: 0844f984b4cd2a23bf2ccf3bf37a38889238d0c3 SHA256: 64b30a3a756e84bf4a6d41a4df1356b919425325d80be5cb5e4c5e38f0acb1b8 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-3.6 Architecture: all Maintainer: Uyuni packagers Installed-Size: 127 Depends: perl Filename: all/perl-ipc-cmd_1.04-3.6_all.deb Size: 33164 MD5sum: 0ede233766e5354c8dd84875b2f4e2cb SHA1: 74e6cf08391dd996896f6bdf4fe178bab0d26b4e SHA256: 90c292099cab236f4c21dc569abad7038eac52cf01b99b7d84533b5cb10d5fe7 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-2.90 Architecture: ppc64el Maintainer: Uyuni packagers Installed-Size: 967 Depends: perl-base,liblua5-1-5,libc6 Filename: ppc64el/perl-lua-api_0.04-2.90_ppc64el.deb Size: 180016 MD5sum: 9d6cd7e096e80d2473eb7f135408047c SHA1: 7b263e86dcaf3b368d410a7463a9c4bc9a18038e SHA256: 5b1d31ecf420962bc9793e46a40ca445c676e9ef03990c895a93539961911833 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-2.90 Architecture: armhf Maintainer: Uyuni packagers Installed-Size: 672 Depends: perl-base,liblua5-1-5,libc6 Filename: armhf/perl-lua-api_0.04-2.90_armhf.deb Size: 169172 MD5sum: 339eb516e40028f109b730404e5922ba SHA1: c2690eee9c2580950f92138d288e99ef945e6cf8 SHA256: 7834e9e1952e63af18ee745a3e65361ce9a12f2634a5b8844bb4668e81d4ff82 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-2.90 Architecture: arm64 Maintainer: Uyuni packagers Installed-Size: 874 Depends: perl-base,liblua5-1-5,libc6 Filename: arm64/perl-lua-api_0.04-2.90_arm64.deb Size: 177612 MD5sum: dec3a17444e7a57059494296fd3b7c88 SHA1: 870ac4e637a9320a4da22d80d0e6e30f168877cf SHA256: 82c5515da05c70e9574e572f001a3e37a0c41c6fd6227c7e17ddefb536abb738 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-2.90 Architecture: amd64 Maintainer: Uyuni packagers Installed-Size: 864 Depends: perl-base,liblua5-1-5,libc6 Filename: amd64/perl-lua-api_0.04-2.90_amd64.deb Size: 183032 MD5sum: e892ed5aa16af3043453c217e92425fd SHA1: 1b8c6c6d9cc034976c15c09b2778ffbf4d150f55 SHA256: cea7c37599bdc79deb276bddafb190fed18cf530de748d27386846f0e7647fa7 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-2.90 Architecture: i386 Maintainer: Uyuni packagers Installed-Size: 722 Depends: perl-base,liblua5-1-5,libc6 Filename: i386/perl-lua-api_0.04-2.90_i386.deb Size: 169940 MD5sum: 32aeeb4c292bb995bab2ded5dae5402e SHA1: 5cdc45a8e4e8a1e56385c6ca4ae98d08e48bd80d SHA256: 9eea72a9466710c4984e538bdeeca07b2991c2c4832705df6f9f716c501ac130 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-2.90 Architecture: s390x Maintainer: Uyuni packagers Installed-Size: 891 Depends: perl-base,liblua5-1-5,libc6 Filename: s390x/perl-lua-api_0.04-2.90_s390x.deb Size: 172120 MD5sum: 219327853e3d669e00540a971bf80bd7 SHA1: bc428b4c059fef000c7594bce1ee4d28751336d7 SHA256: 81df73fbb2593f56d1e4542c2af237fbeda3177617d732f9d6aa5f1fdd1227ed 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-4.25 Architecture: all Maintainer: Uyuni packagers 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-4.25) Filename: all/perl-module-build_0.423400-4.25_all.deb Size: 251380 MD5sum: a6a73a318e65998064b0f5397c4e7b7c SHA1: 83d2f3f2a348eb5169e037344d811768d813583a SHA256: df79c12d08733eab0f3e8fb7076684bac9e231e74f2e6352ba926e8fbebc5528 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 111 Depends: perl Filename: all/perl-module-metadata_1.000038-3.5_all.deb Size: 29660 MD5sum: 5f5fd4a4f8bdcecd02266a872fbd64e5 SHA1: 0985883c046f4506bee05fc658041ed418cefbeb SHA256: a6b39b8cb2f31eb24e000831ec4d639897d4603dc36c602e81379d2f27e1faf4 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-3.42 Architecture: all Maintainer: Uyuni packagers Installed-Size: 74 Filename: all/perl-module-runtime_0.016-3.42_all.deb Size: 18440 MD5sum: 18bbb230f7bd662afedb06c07b9df36a SHA1: 198cd050b94799a464cb198db78727accecf3ea2 SHA256: 9fb76e2efa133647432f9d37f797e902d7927c5f59448a83b2a9c272662e5d7c 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 81 Filename: all/perl-mro-compat_0.15-3.5_all.deb Size: 17208 MD5sum: 188f808b67fd359511c6ef275c8cf61a SHA1: 715717c264be186812d0ecee124f1fe686c5c080 SHA256: f7580e8ba401c9c72815035744286d9e3f0fbcd4f9d776028d964ab0ff459a77 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-1.2 Architecture: all Maintainer: Uyuni packagers Installed-Size: 48 Filename: all/perl-parent_0.241-1.2_all.deb Size: 8868 MD5sum: ae608643b8570c346f4705c1b08d6909 SHA1: 048835141ca4b26f33ca03524db53567dd17f993 SHA256: d7b71cf7eeb8424d7eeba06801ecd156bd1c1096daedd1882dd13bb44e9aaaab 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-3.9 Architecture: all Maintainer: Uyuni packagers Installed-Size: 74 Filename: all/perl-perl-ostype_1.010-3.9_all.deb Size: 15196 MD5sum: 516df25c9c4f0e54bb989bcdd09eb092 SHA1: 924c3e39ef06e5b8ddc5962ba12153be94cd2be4 SHA256: 32aea1a0a1eac3cbebf10064064eb4d4aec7529c70fb899d7806417e3988001c 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-3.11 Architecture: all Maintainer: Uyuni packagers Installed-Size: 85 Depends: perl-devel-symdump,perl Filename: all/perl-pod-coverage_0.23-3.11_all.deb Size: 19112 MD5sum: 068d3128562f4e85115f9a6cae7a6ebf SHA1: 40537588efd0e934a0a47436c2fbeb36462ca9e4 SHA256: 3a47d857e84c6f16507f67f8661fe5b497fee3857dda0908447fd1a8e6b225ce 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-2.42 Architecture: all Maintainer: Uyuni packagers Installed-Size: 112 Filename: all/perl-sub-uplevel_0.2800-2.42_all.deb Size: 22168 MD5sum: 9668226b207add98d639ed5bedb7aa93 SHA1: c7526c118e9a5bd4f65cfb2090c86af12311da86 SHA256: d05d85821190d58b49104953f1c496fb40834702c65cec6fd3c95411d13a3805 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-3.72 Architecture: all Maintainer: Uyuni packagers Installed-Size: 208 Depends: perl-mro-compat,perl-module-runtime,perl,perl-try-tiny Filename: all/perl-test-class_0.52-3.72_all.deb Size: 56800 MD5sum: e694c61b59116273b186b059d9aff6e0 SHA1: be9cd68777b93580ec08cb7457d701620657c6da SHA256: 6ae6f2aa1d49be29e12c08954e23f11f8009b7adeec0637484e54fd30f3fa627 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-3.35 Architecture: all Maintainer: Uyuni packagers Installed-Size: 86 Depends: perl-base,perl-parent Provides: libtest-compile-perl (= 3.3.1-3.35),libtest-compile-internal-perl (= 3.3.1-3.35) Filename: all/perl-test-compile_3.3.1-3.35_all.deb Size: 21448 MD5sum: d29d76b3983d34c09152dc91d6fb159b SHA1: 597dc42ce12f33936cc9232c222f72bb6056938e SHA256: c2f1556fb602de4b1dd0b56a8bfb77c2999bc711409e56c7d01b16bd8128efd4 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-4.9 Architecture: all Maintainer: Uyuni packagers Installed-Size: 353 Depends: perl Filename: all/perl-test-deep_1.204-4.9_all.deb Size: 92708 MD5sum: 48d20f0ae7c130e6f5f2053bdf9fb4b1 SHA1: f3c5b1fd5351327a2dfc7d9b26abe3c0c213ac11 SHA256: 851237b0f5704751f3f5bd3d9c342bf657991838adfe05ccc927bd67910173b3 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-3.14 Architecture: all Maintainer: Uyuni packagers Installed-Size: 73 Depends: perl-capture-tiny,perl,perl-text-diff Provides: libtest-differences-perl (= 0.710.0-3.14) Filename: all/perl-test-differences_0.710.0-3.14_all.deb Size: 18380 MD5sum: 5ef263ee5d1252ed1708f423f34b8d79 SHA1: 3ba63fbb539ade8787e7058f0b3d0949ca820156 SHA256: 8c688774b70be2288ed1737279a314dc4438bb2b40847ef4aa14c416585d229b 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-3.50 Architecture: all Maintainer: Uyuni packagers Installed-Size: 71 Depends: perl-sub-uplevel,perl Provides: libtest-exception-perl (= 0.430000-3.50) Filename: all/perl-test-exception_0.430000-3.50_all.deb Size: 18088 MD5sum: ac886c33e677eeb21d20f9eb23e63aeb SHA1: 60361302e6f9fa29c9327e60609ddbb7e06df6d2 SHA256: 17926ccb646192687763b8ca68573f583e22921c8ecd1bd95f758a1aedbdef31 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 = ; 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-3.72 Architecture: all Maintainer: Uyuni packagers 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-3.72_all.deb Size: 23424 MD5sum: f3eae5c3640155b4cf8bf9c13486004d SHA1: 372e25a898b27ca5e191f02058e4bb45364fb7d0 SHA256: 8648f574d5ad085d7cfcbd223dc5ceff2ea98d95b4f5974420d61fb59983d845 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 62 Depends: perl Filename: all/perl-test-pod_1.52-3.5_all.deb Size: 13316 MD5sum: c4ba63ce0def7e6bbd538322a1ea3fbc SHA1: 881bd3962eb213acc1c9754a4ee7301b7d9fca52 SHA256: dd82421afa94ea1a95a2af7854baae56ce15842c27cf0a10fcc5c5f05217579d 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-3.18 Architecture: all Maintainer: Uyuni packagers Installed-Size: 61 Depends: perl-pod-coverage Filename: all/perl-test-pod-coverage_1.10-3.18_all.deb Size: 10932 MD5sum: 61001edc8bde1e03589f947e022df604 SHA1: b74b2a378428661ea53bd5faa184f79849411a76 SHA256: 3789385fb16ddf4ebaeac54ac293e80ffb73fea2c8c111d71a13424728c3f246 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-3.52 Architecture: all Maintainer: Uyuni packagers Installed-Size: 70 Depends: perl-carp,perl-sub-uplevel Filename: all/perl-test-warn_0.37-3.52_all.deb Size: 14844 MD5sum: 93b89ec2d92aa076f8a152bcc81772cf SHA1: 5fbb20e8eb9422433b3fb8ffb9ce2ed880ac31fe SHA256: 06754de81290e7e8656efeff6d0468bc208bb25a1f4360c380ab8b8d35588d71 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 129 Depends: libalgorithm-diff-perl Filename: all/perl-text-diff_1.45-3.5_all.deb Size: 33336 MD5sum: 4be60cda4fba8ee592e510273887e9c9 SHA1: a7db168e881b86d6cda3fa34afa08a71dd008127 SHA256: c6d3e2116c220446f91e362b9e0ba5b8bca0f8ce32ed5a89203f0ece06cef344 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 80 Filename: all/perl-try-tiny_0.31-3.5_all.deb Size: 23976 MD5sum: 2e16919508e79bc5a1e5e90bf019b6d6 SHA1: 1c019575147adfe1f6c32e9fc9f484d48c32d9a7 SHA256: 100f593b91d37b9989cb27f1d92272f83cff2d92a3d601c6bc75916b6cb43932 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-3.5 Architecture: all Maintainer: Uyuni packagers Installed-Size: 52 Filename: all/perl-universal-require_0.19-3.5_all.deb Size: 8924 MD5sum: 79422842fe98b846595066ef5bce563c SHA1: a54dfb20cfe9f5cf717d35d1bcf69ecab5ea9e92 SHA256: e73699addf6dfa82b7e055bee76189702cd7cad50898574c3aeb510ecff0a440 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.