# packages

pkgId: 96c7a3bcc363f23a0c9ba2dae8e17abbf59f2cc033acac4d257d6059b60ee797
name: perl-Class-C3-XS
arch: src
version: 0.13
epoch: 0
release: 14.1.1
summary: XS speedups for Class::C3
url: http://search.cpan.org/dist/Class-C3-XS/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-C3-XS-0.13-14.1.1.src.rpm
checksum_type: sha256
description:
  This contains XS performance enhancers for Class::C3 version 0.16 and higher.
  The main Class::C3 package will use this package automatically if it can
  find it. Do not use this package directly, use Class::C3 instead.

  This module won't do anything for you if you're running a version of Class::C3
  older than 0.16. (It's not a dependency because it would be circular with the
  optional dep from that package to this one).

  Authors:
  --------
      Brandon L. Black, <blblack@gmail.com>


pkgId: 6051e975cf38399b5eb6d1cfd5622e2ac306033595c57c9055c2899b5594f69b
name: perl-Class-Container
arch: src
version: 0.12
epoch: 0
release: 9.1.1
summary: Glues object frameworks together transparently
url: http://search.cpan.org/dist/Class-Container/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Container-0.12-9.1.1.src.rpm
checksum_type: sha256
description:
  This class facilitates building frameworks of several classes that inter-
  operate. It was first designed and built for HTML::Mason, in which the
  Compiler, Lexer, Interpreter, Resolver, Component, Buffer, and several
  other objects must create each other transparently, passing the appropriate
  parameters to the right class, possibly substituting other subclasses for
  any of these objects.


  Authors:
  --------
      Ken Williams <ken@mathforum.org>
      Dave Rolsky <autarch@urth.org>


pkgId: 674587ab15433ff784c0204ebdd18a1b984e920c9cb15a7ee9f28a8d77fae9ce
name: perl-Class-Data-Inheritable
arch: src
version: 0.08
epoch: 0
release: 72.1.1
summary: Inheritable, overridable class data
url: http://search.cpan.org/dist/Class-Data-Inheritable/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Data-Inheritable-0.08-72.1.1.src.rpm
checksum_type: sha256
description:
  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 overriden.

  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);

    
    $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:

    
    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 overriden a
  method:

    
    Raygun->Suitcase('Orange');

  Now that Raygun has overridden Pere::Ubu futher changes by Pere::Ubu no
  longer effect Raygun.

    
    Pere::Ubu->Suitcase('Samsonite');

  Authors:
  --------
       Original code by Damian Conway.
       Maintained by Michael G Schwern until September 2005.
       Now maintained by Tony Bowden.


pkgId: faa508a2e3aebc3b1a67c7803ba2f732cbaee892ed9d90b7be7ca2f88638091e
name: perl-Class-Date
arch: src
version: 1.1.10
epoch: 0
release: 13.1.1
summary: Class for easy date and time manipulation
url: http://search.cpan.org/dist/Class-Date
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Date-1.1.10-13.1.1.src.rpm
checksum_type: sha256
description:
  This module is intended to provide a general-purpose date and datetime
  type for perl. You have a Class::Date class for absolute date and
  datetime and have a Class::Date::Rel class for relative dates.

  You can use "+", "-", "<" and ">" operators as with native perl data
  types.



  Authors:
  --------
      dLux (Szabo, Balázs) <dlux@kapu.hu>


pkgId: 184ece074d4f3f81e537d86fb3938a15d0da54e77d4fd5cacb9293ddbd025043
name: perl-Class-ISA
arch: src
version: 0.36
epoch: 0
release: 5.1.1
summary: report the search path for a class's ISA tree
url: http://search.cpan.org/dist/Class-ISA/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-ISA-0.36-5.1.1.src.rpm
checksum_type: sha256
description:
  Suppose you have a class (like Food::Fish::Fishstick) that is derived, via
  its @ISA, from one or more superclasses (as Food::Fish::Fishstick is from
  Food::Fish, Life::Fungus, and Chemicals), and some of those superclasses
  may themselves each be derived, via its @ISA, from one or more superclasses
  (as above).

  When, then, you call a method in that class ($fishstick->calories), Perl
  first searches there for that method, but if it's not there, it goes
  searching in its superclasses, and so on, in a depth-first (or maybe
  "height-first" is the word) search. In the above example, it'd first look
  in Food::Fish, then Food, then Matter, then Life::Fungus, then Life, then
  Chemicals.

  This library, Class::ISA, provides functions that return that list -- the
  list (in order) of names of classes Perl would search to find a method,
  with no duplicates.


pkgId: 4f23bcd5656d593fe8a95559a569c08fe5c3678ed3e47d56d6356d2cb2469aec
name: perl-Class-Inner
arch: src
version: 0.200001
epoch: 0
release: 8.1.1
summary: A perlish implementation of Java like inner classes
url: http://search.cpan.org/dist/Class-Inner/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Inner-0.200001-8.1.1.src.rpm
checksum_type: sha256
description:
  Yet another implementation of an anonymous class with per object
  overrideable methods, but with the added attraction of sort of working
  dispatch to the parent class's method.


pkgId: 70e39c0d47fe42cd9b71eec86e42fd8e2df4bf6e1b642672bca07b249e9e072b
name: perl-Class-Inspector
arch: src
version: 1.27
epoch: 0
release: 4.1.1
summary: Get information about a class and its structure
url: http://search.cpan.org/dist/Class-Inspector/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Inspector-1.27-4.1.1.src.rpm
checksum_type: sha256
description:
  Class::Inspector allows you to get information about a loaded class. Most
  or all of this information can be found in other ways, but they aren't
  always very friendly, and usually involve a relatively high level of Perl
  wizardry, or strange and unusual looking code. Class::Inspector attempts to
  provide an easier, more friendly interface to this information.


pkgId: 501fd7073c0ed27a778aada61322851459f9f92d57280d90fc6bf76f99d1d9a7
name: perl-Class-Load
arch: src
version: 0.18
epoch: 0
release: 5.1.1
summary: a working (require "Class::Name") and more
url: http://search.cpan.org/dist/Class-Load/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Load-0.18-5.1.1.src.rpm
checksum_type: sha256
description:
  'require EXPR' only accepts 'Class/Name.pm' style module names, not
  'Class::Name'. How frustrating! For that, we provide 'load_class
  'Class::Name''.

  It's often useful to test whether a module can be loaded, instead of
  throwing an error when it's not available. For that, we provide
  'try_load_class 'Class::Name''.

  Finally, sometimes we need to know whether a particular class has been
  loaded. Asking '%INC' is an option, but that will miss inner packages and
  any class for which the filename does not correspond to the package name.
  For that, we provide 'is_class_loaded 'Class::Name''.


pkgId: 5acea31c255287aa19b5ae8f9f425410fc41af7132f6d9735d48e93f9dfa6bf9
name: perl-Class-Load-XS
arch: src
version: 0.04
epoch: 0
release: 6.1.1
summary: XS implementation of parts of Class::Load
url: http://search.cpan.org/dist/Class-Load-XS/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Load-XS-0.04-6.1.1.src.rpm
checksum_type: sha256
description:
  This module provides an XS implementation for portions of the Class::Load
  manpage. See the Class::Load manpage for API details.


pkgId: 9c90d7f8e3c366d720eefbcaaf59c08d9901e782d30c563de36dcd18cb0a3b8c
name: perl-Class-MakeMethods
arch: src
version: 1.01
epoch: 0
release: 4.1.1
summary: Generate common types of methods
url: http://search.cpan.org/dist/Class-MakeMethods/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-MakeMethods-1.01-4.1.1.src.rpm
checksum_type: sha256
description:
  The Class::MakeMethods framework allows Perl class developers to quickly
  define common types of methods. When a module uses Class::MakeMethods or
  one of its subclasses, it can select from a variety of supported method
  types, and specify a name for each method desired. The methods are
  dynamically generated and installed in the calling package.


pkgId: fd25de184cb2ce3f575c807e052b64b3c1a451bd04270b8007b55cd59385424c
name: perl-Class-Method-Modifiers
arch: src
version: 1.09
epoch: 0
release: 4.1.1
summary: Provides Moose-like method modifiers
url: http://search.cpan.org/dist/Class-Method-Modifiers/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Method-Modifiers-1.09-4.1.1.src.rpm
checksum_type: sha256
description:
  Method modifiers are a convenient feature from the CLOS (Common Lisp Object
  System) world.

  In its most basic form, a method modifier is just a method that calls
  '$self->SUPER::foo(@_)'. I for one have trouble remembering that exact
  invocation, so my classes seldom re-dispatch to their base classes. Very
  bad!

  'Class::Method::Modifiers' provides three modifiers: 'before', 'around',
  and 'after'. 'before' and 'after' are run just before and after the method
  they modify, but can not really affect that original method. 'around' is
  run in place of the original method, with a hook to easily call that
  original method. See the 'MODIFIERS' section for more details on how the
  particular modifiers work.

  One clear benefit of using 'Class::Method::Modifiers' is that you can
  define multiple modifiers in a single namespace. These separate modifiers
  don't need to know about each other. This makes top-down design easy. Have
  a base class that provides the skeleton methods of each operation, and have
  plugins modify those methods to flesh out the specifics.

  Parent classes need not know about 'Class::Method::Modifiers'. This means
  you should be able to modify methods in _any_ subclass. See the
  Term::VT102::ZeroBased manpage for an example of subclassing with CMM.

  In short, 'Class::Method::Modifiers' solves the problem of making sure you
  call '$self->SUPER::foo(@_)', and provides a cleaner interface for it.

  As of version 1.00, 'Class::Method::Modifiers' is faster in some cases than
  the Moose manpage. See 'benchmark/method_modifiers.pl' in the the Moose
  manpage distribution.


pkgId: cecb851faab6d679bc8b481dc06a671fc8f0e71d2109e8fe657b23a09e6d17be
name: perl-Class-Method-Modifiers-Fast
arch: src
version: 0.041
epoch: 0
release: 9.1.1
summary: provides Moose-like method modifiers
url: http://search.cpan.org/dist/Class-Method-Modifiers-Fast/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Method-Modifiers-Fast-0.041-9.1.1.src.rpm
checksum_type: sha256
description:
  Method modifiers are a powerful feature from the CLOS (Common Lisp Object
  System) world.

  'Class::Method::Modifiers::Fast' provides three modifiers: 'before',
  'around', and 'after'. 'before' and 'after' are run just before and after
  the method they modify, but can not really affect that original method.
  'around' is run in place of the original method, with a hook to easily call
  that original method. See the 'MODIFIERS' section for more details on how
  the particular modifiers work.


pkgId: 738d88c94022098619c2c19c3bc764bea90f2ba01fc6d299778cf2194c374fb0
name: perl-Class-MethodMaker
arch: src
version: 2.18
epoch: 0
release: 8.1.1
summary: Create generic methods for OO Perl
url: http://search.cpan.org/dist/Class-MethodMaker/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-MethodMaker-2.18-8.1.1.src.rpm
checksum_type: sha256
description:
  This module solves the problem of having to continually write accessor
  methods for your objects that perform standard tasks.

  The argument to 'use' is an *arrayref*, as pairs whose "keys" are the names
  of types of generic methods generated by MethodMaker and whose "values"
  tell method maker what methods to make.

  To override any generated methods, it is sufficient to ensure that the
  overriding method is defined when Class::MethodMaker is called. Note that
  the 'use' keyword introduces a 'BEGIN' block, so you may need to define (or
  at least declare) your overriding method in a 'BEGIN' block.


pkgId: a23d967a2f28ea576e930a947b63987db99d5095a859466884ba2ac7e5f4e11b
name: perl-Class-Multimethods
arch: src
version: 1.70
epoch: 0
release: 589.1.1
summary: This Package Supports Multimethods and Subroutine Overloading in Perl.
url: http://cpan.org/modules/by-module/Class
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Multimethods-1.70-589.1.1.src.rpm
checksum_type: sha256
description:
  Class::Multimethods -- Supports multimethods and subroutine overloading
  in Perl.



  Authors:
  --------
      Damian Conway <damian@cs.monash.edu.au>


pkgId: a9d505419da07b1ff545bbbdd2b85c0a128374ee7fe83012abbd51f707c977ca
name: perl-Class-ReturnValue
arch: src
version: 0.55
epoch: 0
release: 9.1.1
summary: Return-value object that lets you treat it as as a boolean, array or object
url: http://search.cpan.org/dist/Class-ReturnValue/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-ReturnValue-0.55-9.1.1.src.rpm
checksum_type: sha256
description:
  Class::ReturnValue is a "clever" return value object that can allow code
  calling your routine to expect: a boolean value (did it fail) or a list
  (what are the return values)


pkgId: 2191bf8adfcbe2ee0d3269b657d1326a3810f6887c62d1b0d93e867f4d45d492
name: perl-Class-Singleton
arch: src
version: 1.4
epoch: 0
release: 14.1.1
summary: Implementation of a "Singleton" class
url: http://search.cpan.org/dist/Class-Singleton/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Singleton-1.4-14.1.1.src.rpm
checksum_type: sha256
description:
  This is the "Class::Singleton" module. A Singleton describes an object
  class that can have only one instance in any system. An example of a
  Singleton might be a print spooler or system registry. This module
  implements a Singleton class from which other classes can be derived. By
  itself, the "Class::Singleton" module does very little other than manage
  the instantiation of a single object. In deriving a class from
  "Class::Singleton", your module will inherit the Singleton instantiation
  method and can implement whatever specific functionality is required.

  For a description and discussion of the Singleton class, see "Design
  Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.

  Author: Andy Wardley <abw@wardley.org>


pkgId: 650d4010cd9c9f5066f7764e7b01b8eee40a35efa4fd743017c3753d29643c6e
name: perl-Class-Spiffy
arch: src
version: 0.15
epoch: 0
release: 132.1.1
summary: Spiffy Framework with No Source Filtering
url: http://search.cpan.org/dist/Class-Spiffy/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Spiffy-0.15-132.1.1.src.rpm
checksum_type: sha256
description:
  "Class::Spiffy" is a framework and methodology for doing object oriented
  (OO) programming in Perl. Class::Spiffy combines the best parts of
  Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation
  class. It attempts to fix all the nits and warts of traditional Perl OO, in
  a clean, straightforward and (perhaps someday) standard way.


pkgId: 3fb377901e8fb2057e0d086a0728de38c1d2c66e10ae3e24e902d5519d7b3587
name: perl-Class-Std
arch: src
version: 0.011
epoch: 0
release: 9.1.1
summary: Support for creating standard "inside-out" classes
url: http://search.cpan.org/dist/Class-Std/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-Std-0.011-9.1.1.src.rpm
checksum_type: sha256
description:
  This module provides tools that help to implement the "inside out object"
  class structure in a convenient and standard way.

  Authors:
  --------
      Damian Conway <DCONWAY@cpan.org>


pkgId: 4a55168738daf2602c4636481229351bb80cbb5b411e2f96a1ef46276f286175
name: perl-Class-WhiteHole
arch: src
version: 0.04
epoch: 0
release: 222.1.1
summary: Base class to treat unhandled method calls as errors
url: http://cpan.org/modules/by-module/Class/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-WhiteHole-0.04-222.1.1.src.rpm
checksum_type: sha256
description:
  It's possible to accidentally inherit an AUTOLOAD method. Often this
  will happen if a class somewhere in the chain uses AutoLoader or
  defines one of their own. This can lead to confusing error messages
  when method lookups fail.

  Sometimes you want to avoid this accidental inheritance.  In that case,
  inherit from Class::WhiteHole. All unhandled methods will produce
  normal Perl error messages.



  Authors:
  --------
      Michael G Schwern <schwern@pobox.com>


pkgId: 791412b85982a0ae3bfb76f21afa7fbc49b4c2e902d51ca323ce7a031554a242
name: perl-Class-XPath
arch: src
version: 1.4
epoch: 0
release: 156.1.1
summary: Adds xpath matching to object trees
url: http://search.cpan.org/dist/Class-XPath/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-XPath-1.4-156.1.1.src.rpm
checksum_type: sha256
description:
  This module adds XPath-style matching to your object trees. This means that
  you can find nodes using an XPath-esque query with 'match()' from anywhere
  in the tree. Also, the 'xpath()' method returns a unique path to a given
  node which can be used as an identifier.

  To use this module you must already have an OO implementation of a tree.
  The tree must be a true tree - all nodes have a single parent and the tree
  must have a single root node. Also, the order of children within a node
  must be stable.

  *NOTE:* This module is not yet a complete XPath implementation. Over time I
  expect the subset of XPath supported to grow. See the SYNTAX documentation
  for details on the current level of support.


pkgId: 295cde225386705bcdd37bb5d0b940a0fffb62b896df1aa2f0adc4e698cac69c
name: perl-Class-XSAccessor
arch: src
version: 1.13
epoch: 0
release: 4.1.1
summary: Generate fast XS accessors without runtime compilation
url: http://search.cpan.org/dist/Class-XSAccessor/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Class-XSAccessor-1.13-4.1.1.src.rpm
checksum_type: sha256
description:
  Class::XSAccessor implements fast read, write and read/write accessors in
  XS. Additionally, it can provide predicates such as 'has_foo()' for testing
  whether the attribute 'foo' is defined in the object. It only works with
  objects that are implemented as ordinary hashes. the
  Class::XSAccessor::Array manpage implements the same interface for objects
  that use arrays for their internal representation.

  Since version 0.10, the module can also generate simple constructors
  (implemented in XS). Simply supply the 'constructor => 'constructor_name''
  option or the 'constructors => ['new', 'create', 'spawn']' option. These
  constructors do the equivalent of the following Perl code:

    sub new {
      my $class = shift;
      return bless { @_ }, ref($class)||$class;
    }

  That means they can be called on objects and classes but will not clone
  objects entirely. Parameters to 'new()' are added to the object.

  The XS accessor methods are between 3 and 4 times faster than typical
  pure-Perl accessors in some simple benchmarking. The lower factor applies
  to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} =
  $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a
  good estimate. If in doubt, do your own benchmarking!

  The method names may be fully qualified. The example in the synopsis could
  have been written as 'MyClass::get_foo' instead of 'get_foo'. This way,
  methods can be installed in classes other than the current class. See also:
  the 'class' option below.

  By default, the setters return the new value that was set, and the
  accessors (mutators) do the same. This behaviour can be changed with the
  'chained' option - see below. The predicates return a boolean.

  Since version 1.01, 'Class::XSAccessor' can generate extremely simple
  methods which just return true or false (and always do so). If that seems
  like a really superfluous thing to you, then consider a large class
  hierarchy with interfaces such as the PPI manpage. These methods are
  provided by the 'true' and 'false' options - see the synopsis.


pkgId: 0bdede97458fdc1e84dad27e5b41e57e33614d5954e226f7c59101b36009611e
name: perl-Clipboard
arch: src
version: 0.13
epoch: 0
release: 4.1.1
summary: Copy and Paste with any OS
url: http://search.cpan.org/dist/Clipboard
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Clipboard-0.13-4.1.1.src.rpm
checksum_type: sha256
description:
  Who doesn't remember the first time they learned to copy and paste, and
  generated an exponentially growing text document? Yes, that's right,
  clipboards are magical.

  With Clipboard.pm, this magic is now trivial to access, in a
  cross-platform-consistent API, from your Perl code.


pkgId: 5fef864effafc46ecf686590bb50e3b9570cc000aed2626d56e1febead368393
name: perl-Clone
arch: src
version: 0.31
epoch: 0
release: 21.1.1
summary: Recursively copy Perl datatypes
url: http://search.cpan.org/dist/Clone/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Clone-0.31-21.1.1.src.rpm
checksum_type: sha256
description:
  This module provides a clone() method which makes recursive copies of
  nested hash, array, scalar and reference types, including tied variables
  and objects.

  For a slower, but more flexible solution see Storable's dclone().


pkgId: 846487bd53183e3d882a5bd2ba6346e75bbe39c612e97a23f1e3eab044221581
name: perl-Clone-PP
arch: src
version: 1.02
epoch: 0
release: 10.1.1
summary: Recursively copy Perl datatypes
url: http://search.cpan.org/dist/Clone-PP/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: nosrc/perl-Clone-PP-1.02-10.1.1.nosrc.rpm
checksum_type: sha256
description:
  This module provides a general-purpose clone function to make deep copies
  of Perl data structures. It calls itself recursively to copy nested hash,
  array, scalar and reference types, including tied variables and objects.

  The clone() function takes a scalar argument to copy. To duplicate arrays
  or hashes, pass them in by reference:

    my $copy = clone(\@array);    my @copy = @{ clone(\@array) };
    my $copy = clone(\%hash);     my %copy = %;

  The clone() function also accepts an optional second parameter that can be
  used to limit the depth of the copy. If you pass a limit of 0, clone will
  return the same value you supplied; for a limit of 1, a shallow copy is
  constructed; for a limit of 2, two layers of copying are done, and so on.

    my $shallow_copy = clone( $item, 1 );

  To allow objects to intervene in the way they are copied, the clone()
  function checks for a couple of optional methods. If an object provides a
  method named 'clone_self', it is called and the result returned without
  further processing. Alternately, if an object provides a method named
  'clone_init', it is called on the copied object before it is returned.


pkgId: fa594d058703cf317002b1979cd9a9b68b57c9d13db747a01fa8a17ec3d96ea2
name: perl-Compress-Bzip2
arch: src
version: 2.09
epoch: 0
release: 2.1.1
summary: Interface to Bzip2 compression library
url: http://cpan.org/modules/by-module/Compress/
rpm_license: GPL+ or Artistic
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Compress-Bzip2-2.09-2.1.1.src.rpm
checksum_type: sha256
description:
  The Compress::Bzip2 module provides a Perl interface to the Bzip2 compression
   library (see "AUTHOR" for details about where to get Bzip2). A relevant subset
   of the functionality provided by Bzip2 is available in Compress::Bzip2.


pkgId: a3d0eb6ccf30defe96cba189effcfa47440ebbbb4435aa5d914608789f050a69
name: perl-Config-Any
arch: src
version: 0.23
epoch: 0
release: 4.1.1
summary: Load configuration from different file formats, transparently
url: http://search.cpan.org/dist/Config-Any/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Any-0.23-4.1.1.src.rpm
checksum_type: sha256
description:
  Config::Any provides a facility for Perl applications and libraries to load
  configuration data from multiple different file formats. It supports XML,
  YAML, JSON, Apache-style configuration, Windows INI files, and even Perl
  code.

  The rationale for this module is as follows: Perl programs are deployed on
  many different platforms and integrated with many different systems.
  Systems administrators and end users may prefer different configuration
  formats than the developers. The flexibility inherent in a multiple format
  configuration loader allows different users to make different choices,
  without generating extra work for the developers. As a developer you only
  need to learn a single interface to be able to use the power of different
  configuration formats.


pkgId: f1ce4092300efda3697b41428a9f02079a3398469bc9cb6ebb7dcaee3159441d
name: perl-Config-Auto
arch: src
version: 0.42
epoch: 0
release: 4.1.1
summary: Magical config file parser
url: http://search.cpan.org/dist/Config-Auto/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Auto-0.42-4.1.1.src.rpm
checksum_type: sha256
description:
  This module was written after having to write Yet Another Config File
  Parser for some variety of colon-separated config. I decided "never again".

  Config::Auto aims to be the most 'DWIM' config parser available, by
  detecting configuration styles, include paths and even config filenames
  automagically.

  See the the HOW IT WORKS manpage section below on implementation details.


pkgId: 5e444a17485c568e7773e8576b81ed4366baee698e7de5a5f1b7227dd7f99773
name: perl-Config-Crontab
arch: src
version: 1.33
epoch: 0
release: 5.1.1
summary: Read/Write Vixie compatible crontab(5) files
url: http://search.cpan.org/dist/Config-Crontab/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Crontab-1.33-5.1.1.src.rpm
checksum_type: sha256
description:
  *Config::Crontab* provides an object-oriented interface to Vixie-style
  crontab(5) files for Perl.

  A *Config::Crontab* object allows you to manipulate an ordered set of
  *Event*, *Env*, or *Comment* objects (also included with this package).
  Descriptions of these packages may be found below.

  In short, *Config::Crontab* reads and writes crontab(5) files (and does a
  little pretty-printing too) using objects. The general idea is that you
  create a *Config::Crontab* object and associate it with a file (if
  unassociated, it will work over a pipe to 'crontab -l'). From there, you
  can add lines to your crontab object, change existing line attributes, and
  write everything back to file.

  Now, to successfully navigate the module's ins and outs, we'll need a
  little terminology lesson.


pkgId: 443c4f2eed7c513b4e1b3ed9da422b59048dfc9ec90a85f80da76ff14517d490
name: perl-Config-General
arch: src
version: 2.50
epoch: 0
release: 10.1.1
summary: Generic Config Module
url: http://search.cpan.org/dist/Config-General/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-General-2.50-10.1.1.src.rpm
checksum_type: sha256
description:
  This module opens a config file and parses its contents for you. The *new*
  method requires one parameter which needs to be a filename. The method
  *getall* returns a hash which contains all options and its associated
  values of your config file.

  The format of config files supported by *Config::General* is inspired by
  the well known Apache config format, in fact, this module is 100%
  compatible to Apache configs, but you can also just use simple name/value
  pairs in your config files.

  In addition to the capabilities of an Apache config file it supports some
  enhancements such as here-documents, C-style comments or multiline options.


pkgId: ad0dc3c2e37f6feb27693918eda9265b47d5ad01948f448a62c10b4ca319579c
name: perl-Config-GitLike
arch: src
version: 1.08
epoch: 0
release: 4.1.1
summary: Git-compatible config file parsing
url: http://search.cpan.org/dist/Config-GitLike/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-GitLike-1.08-4.1.1.src.rpm
checksum_type: sha256
description:
  This module handles interaction with configuration files of the style used
  by the version control system Git. It can both parse and modify these
  files, as well as create entirely new ones.

  You only need to know a few things about the configuration format in order
  to use this module. First, a configuration file is made up of key/value
  pairs. Every key must be contained in a section. Sections can have
  subsections, but they don't have to. For the purposes of setting and
  getting configuration variables, we join the section name, subsection name,
  and variable name together with dots to get a key name that looks like
  "section.subsection.variable". These are the strings that you'll be passing
  in to 'key' arguments.

  Configuration files inherit from each other. By default, 'Config::GitLike'
  loads data from a system-wide configuration file, a per-user configuration
  file, and a per-directory configuration file, but by subclassing and
  overriding methods you can obtain any combination of configuration files.
  By default, configuration files that don't exist are just skipped.

  See the
  http://www.kernel.org/pub/software/scm/git/docs/git-config.html#_configurat
  ion_file manpage for details on the syntax of git configuration files. We
  won't waste pixels on the nitty gritty here.

  While the behavior of a couple of this module's methods differ slightly
  from the 'git config' equivalents, this module can read any config file
  written by git. The converse is usually true, but only if you don't take
  advantage of this module's increased permissiveness when it comes to key
  names. (See the DIFFERENCES FROM GIT-CONFIG manpage for details.)

  This is an object-oriented module using Any::Moose. All subroutines are
  object method calls.

  A few methods have parameters that are always used for the same purpose:


pkgId: d0eae7e2e2f252b4a35a90897b13ef6170f8c6b229eb77f34e7f5e7634d3ffba
name: perl-Config-Grammar
arch: src
version: 1.10
epoch: 0
release: 4.1.1
summary: A grammar-based, user-friendly config parser
url: http://search.cpan.org/dist/Config-Grammar/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Grammar-1.10-4.1.1.src.rpm
checksum_type: sha256
description:
  Config::Grammar is a module to parse configuration files. The configuration
  may consist of multiple-level sections with assignments and tabular data.
  The parsed data will be returned as a hash containing the whole
  configuration. Config::Grammar uses a grammar that is supplied upon
  creation of a Config::Grammar object to parse the configuration file and
  return helpful error messages in case of syntax errors. Using the *makepod*
  method you can generate documentation of the configuration file format.

  The *maketmpl* method can generate a template configuration file. If your
  grammar contains regexp matches, the template will not be all that helpful
  as Config::Grammar is not smart enough to give you sensible template data
  based in regular expressions. The related function *maketmplmin* generates
  a minimal configuration template without examples, regexps or comments and
  thus allows an experienced user to fill in the configuration data more
  efficiently.


pkgId: 3b7c436510f1104856f6a75cbd24ea70ffadd55d062e93d0c18a5633bfe68006
name: perl-Config-IniFiles
arch: src
version: 2.75
epoch: 0
release: 4.1.1
summary: Module for reading .ini-style configuration files
url: http://search.cpan.org/dist/Config-IniFiles/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-IniFiles-2.75-4.1.1.src.rpm
checksum_type: sha256
description:
  Config::IniFiles provides a way to have readable configuration files
  outside your Perl script. Configurations can be imported (inherited,
  stacked,...), sections can be grouped, and settings can be accessed from a
  tied hash.



  Authors:
  --------
      Scott Hutton
      Rich Bowen <rbowen@rcbowen.com>
      Jeremy Wadsack <dgsupport at wadsack-allen dot com>


pkgId: 865249a6bbd6bd292c9ba381bbfe11fd76eae73360103d2432a16dabc5d862f6
name: perl-Config-MVP
arch: src
version: 2.200001
epoch: 0
release: 4.1.1
summary: multivalue-property package-oriented configuration
url: http://search.cpan.org/dist/Config-MVP/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-MVP-2.200001-4.1.1.src.rpm
checksum_type: sha256
description:
  MVP is a mechanism for loading configuration (or other information) for
  libraries. It doesn't read a file or a database. It's a helper for things
  that do.

  The idea is that you end up with a Config::MVP::Sequence object, and that
  you can use that object to fully configure your library or application. The
  sequence will contain a bunch of Config::MVP::Section objects, each of
  which is meant to provide configuration for a part of your program. Most of
  these sections will be directly related to a Perl library that you'll use
  as a plugin or helper. Each section will have a name, and every name in the
  sequence will be unique.

  This is a pretty abstract set of behaviors, so we'll provide some more
  concrete examples that should help explain how things work.


pkgId: 4783c9b65f21e9add7ae7ee2dbdf8aa0864862c0632a5a9c857517fffdaf4fc9
name: perl-Config-Simple
arch: src
version: 4.59
epoch: 0
release: 14.1.1
summary: Simple configuration file class
url: http://search.cpan.org/perldoc?Config::Simple
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Simple-4.59-14.1.1.src.rpm
checksum_type: sha256
description:
  Reading and writing configuration files is one of the most frequent tasks of
  any software design. Config::Simple is the library that helps you with it.

  Config::Simple is a class representing configuration file object. It supports
  several configuration file syntax and tries to identify the file syntax
  automatically. Library supports parsing, updating and creating configuration
  files.


pkgId: 99e709e66f70d3f7a62a1d22cd67c96fc466b2bc1f0c021f83e116640623918e
name: perl-Config-Std
arch: src
version: 0.900
epoch: 0
release: 4.1.1
summary: Load and save configuration files in a standard format
url: http://search.cpan.org/dist/Config-Std/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Std-0.900-4.1.1.src.rpm
checksum_type: sha256
description:
  This module implements yet another damn configuration-file system.

  The configuration language is deliberately simple and limited, and the
  module works hard to preserve as much information (section order, comments,
  etc.) as possible when a configuration file is updated.

  The whole point of Config::Std is to encourage use of one standard layout
  and syntax in config files. Damian says "I could have gotten away with it,
  I would have only allowed one separator. But it proved impossible to choose
  between ':' and '=' (half the people I asked wanted one, half wanted the
  other)." Providing round-trip file re-write is the spoonful of sugar to
  help the medicine go down. The supported syntax is within the general INI
  file family

  See Chapter 19 of "Perl Best Practices" (O'Reilly, 2005) for more detail on
  the rationale for this approach.


pkgId: 43e4e14465b9b468e281112f1511abf459b8e7f827dd7ce5ed0760d270d69bf1
name: perl-Config-Tiny
arch: src
version: 2.14
epoch: 0
release: 9.1.1
summary: Read/Write .ini style files with as little code as possible
url: http://search.cpan.org/dist/Config-Tiny/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Config-Tiny-2.14-9.1.1.src.rpm
checksum_type: sha256
description:
  'Config::Tiny' is a perl class to read and write .ini style configuration
  files with as little code as possible, reducing load time and memory
  overhead. Most of the time it is accepted that Perl applications use a lot
  of memory and modules. The '::Tiny' family of modules is specifically
  intended to provide an ultralight alternative to the standard modules.

  This module is primarily for reading human written files, and anything we
  write shouldn't need to have documentation/comments. If you need something
  with more power move up to the Config::Simple manpage, the Config::General
  manpage or one of the many other 'Config::' modules. To rephrase, the
  Config::Tiny manpage does *not* preserve your comments, whitespace, or the
  order of your config file.




  Authors:
  --------
       Adam Kennedy <adamk@cpan.org>


pkgId: b4b632d9aa557f8a3d15387ee3acae2bfd3ba75504916abad6c4deb551e586d1
name: perl-Context-Preserve
arch: src
version: 0.01
epoch: 0
release: 4.1.1
url: http://search.cpan.org/dist/Context-Preserve/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Context-Preserve-0.01-4.1.1.src.rpm
checksum_type: sha256
summary:
  run code after a subroutine call, preserving the context the subroutine would have seen if it were the last statement in the caller

description:
  Sometimes you need to call a function, get the results, act on the results,
  then return the result of the function. This is painful because of
  contexts; the original function can behave different if it's called in
  void, scalar, or list context. You can ignore the various cases and just
  pick one, but that's fragile. To do things right, you need to see which
  case you're being called in, and then call the function in that context.
  This results in 3 code paths, which is a pain to type in (and maintain).

  This module automates the process. You provide a coderef that is the
  "original function", and another coderef to run after the original runs.
  You can modify the return value (aliased to @_) here, and do whatever else
  you need to do. 'wantarray' is correct inside both coderefs; in "after",
  though, the return value is ignored and the value 'wantarray' returns is
  related to the context that the original function was called in.


pkgId: 6e3436e86648f7e6430473a7dd9a12762d4d55a6637726b41f91d0ae1636038e
name: perl-Contextual-Return
arch: src
version: 0.004007
epoch: 0
release: 2.1.1
summary: Create context-sensitive return values
url: http://search.cpan.org/dist/Contextual-Return/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Contextual-Return-0.004007-2.1.1.src.rpm
checksum_type: sha256
description:
  Usually, when you need to create a subroutine that returns different values
  in different contexts (list, scalar, or void), you write something like:

      sub get_server_status {
          my ($server_ID) = @_;

          
          my %server_data = _ascertain_server_status($server_ID);

          
          
          if (wantarray()) {
              return @server_data{ qw(name uptime load users) };
          }
          if (defined wantarray()) {
              return $server_data{load};
          }
          if (!defined wantarray()) {
              carp 'Useless use of get_server_status() in void context';
              return;
          }
          else {
              croak q{Bad context! No biscuit!};
          }
      }

  That works okay, but the code could certainly be more readable. In its
  simplest usage, this module makes that code more readable by providing
  three subroutines--'LIST()', 'SCALAR()', 'VOID()'--that are true only when
  the current subroutine is called in the corresponding context:

      use Contextual::Return;

      sub get_server_status {
          my ($server_ID) = @_;

          
          my %server_data = _ascertain_server_status($server_ID);

          
          
          if (LIST)   { return @server_data{ qw(name uptime load users) } }
          if (SCALAR) { return $server_data{load}                         }
          if (VOID)   { print "$server_data{load}\n"                      }
          else        { croak q{Bad context! No biscuit!}                 }
      }


pkgId: f302232cda53ae27185bef0e0235b357a091822b434c1287c72ab97e1a20b473
name: perl-Convert-ASN1
arch: src
version: 0.22
epoch: 0
release: 24.1.1
summary: ASN.1 Encode/Decode library
url: http://search.cpan.org/dist/Convert-ASN1/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Convert-ASN1-0.22-24.1.1.src.rpm
checksum_type: sha256
description:
  Convert::ASN1 encodes and decodes ASN.1 data structures using BER/DER
  rules.

  Authors:
  --------
       Graham Barr <gbarr@pobox.com>, Report bugs via
       <bug-Convert-ASN1@rt.cpan.org>


pkgId: 97ebff89d24c0a10590cfb94164c3d04945de74a52bf884b9b588ae915e71bc7
name: perl-Convert-BER
arch: src
version: 1.32
epoch: 0
release: 22.1.1
summary: ASN.1 Basic Encoding Rules
url: http://search.cpan.org/dist/Convert-BER
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Convert-BER-1.32-22.1.1.src.rpm
checksum_type: sha256
description:
  Convert::BER is a Perl object class implementation for encoding and
  decoding objects as described by ITU-T standard X.209 (ASN.1) using
  Basic Encoding Rules (BER).

  WARNING this module is no longer supported, See Convert::ASN1


pkgId: 6638ed5459a7aa1711a001cdb78ad0903eb23bd43a0614d0ee0c9f6c77151b4f
name: perl-Convert-BinHex
arch: src
version: 1.119
epoch: 0
release: 23.1.1
summary: Extract data from Macintosh BinHex files
url: http://search.cpan.org/perldoc?Convert::BinHex
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Convert-BinHex-1.119-23.1.1.src.rpm
checksum_type: sha256
description:
  BinHex is a format used by Macintosh for transporting Mac files safely through
  electronic mail, as short-lined, 7-bit, semi-compressed data streams. This
  module provides a means of converting those data streams back into binary
  data.

  Authors:
  -------
      Written by Eryq, http://www.enteract.com/~eryq / eryq@enteract.com


pkgId: f8554ea696c3af3d96812e0c9456346be901af44db871a2a308abb515e32b92b
name: perl-Crypt-Blowfish
arch: src
version: 2.12
epoch: 0
release: 23.1.1
summary: Perl Blowfish encryption module
url: http://search.cpan.org/dist/Crypt-Blowfish/
rpm_license: BSD-3-Clause
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-Blowfish-2.12-23.1.1.src.rpm
checksum_type: sha256
description:
  Blowfish is capable of strong encryption and can use key sizes up to 56
  bytes (a 448 bit key). You're encouraged to take advantage of the full key
  size to ensure the strongest encryption possible from this module.


pkgId: 7f6b7e4ba1737fa2d68869b54f6e2e468cc42eb3ee9d2228317a6a2bd499a710
name: perl-Crypt-CBC
arch: src
version: 2.30
epoch: 0
release: 26.1.1
summary: Encrypt Data with Cipher Block Chaining Mode
url: http://search.cpan.org/dist/Crypt-CBC/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-CBC-2.30-26.1.1.src.rpm
checksum_type: sha256
description:
  This module is a Perl-only implementation of the cryptographic cipher block
  chaining mode (CBC). In combination with a block cipher such as DES or
  IDEA, you can encrypt and decrypt messages of arbitrarily long length. The
  encrypted messages are compatible with the encryption format used by the
  *OpenSSL* package.


pkgId: e6c89f070714be27d6c7579805363db24e28badeab1e6d0bbe6c42a11309defb
name: perl-Crypt-DES
arch: src
version: 2.05
epoch: 0
release: 157.1.1
summary: Perl DES encryption module
url: http://search.cpan.org/dist/Crypt-DES/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-DES-2.05-157.1.1.src.rpm
checksum_type: sha256
description:
  The module implements the Crypt::CBC interface, which has the following
  methods

  * blocksize
    =item keysize
    =item encrypt
    =item decrypt

  Authors:
  --------
      Eric Young (eay@mincom.oz.au)


pkgId: 922a553c62c8360901984c990c94101b1ae197b6b9f24b1ed06041ea42863af6
name: perl-Crypt-OpenSSL-Bignum
arch: src
version: 0.04
epoch: 0
release: 21.1.1
summary: OpenSSL's multiprecision integer arithmetic
url: http://search.cpan.org/dist/Crypt-OpenSSL-Bignum/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-OpenSSL-Bignum-0.04-21.1.1.src.rpm
checksum_type: sha256
description:
  Crypt::OpenSSL::Bignum provides access to OpenSSL multiprecision integer
  arithmetic libraries. Presently, many though not all of the arithmetic
  operations that OpenSSL provides are exposed to perl. In addition, this
  module can be used to provide access to bignum values produced by other
  OpenSSL modules, such as key parameters from Crypt::OpenSSL::RSA.


pkgId: 6ebbb81199a84439f9be18939b17ca8c7556e6dc816379b2659c18b15adafbbe
name: perl-Crypt-OpenSSL-RSA
arch: src
version: 0.28
epoch: 0
release: 5.1.1
summary: RSA encoding and decoding, using the openSSL libraries
url: http://search.cpan.org/dist/Crypt-OpenSSL-RSA
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-OpenSSL-RSA-0.28-5.1.1.src.rpm
checksum_type: sha256
description:
  Crypt::OpenSSL::RSA is an XS perl module designed to provide basic RSA
  functionality.  It does this by providing a glue to the RSA functions
  in the OpenSSL library.


pkgId: e96ae264f4709a958edde870943e1a83bc303e855f9ab29e64f81a9ee2ed3e83
name: perl-Crypt-OpenSSL-Random
arch: src
version: 0.04
epoch: 0
release: 21.1.1
summary: Crypt::OpenSSL::Random Perl module
url: http://search.cpan.org/dist/Crypt-OpenSSL-Random/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-OpenSSL-Random-0.04-21.1.1.src.rpm
checksum_type: sha256
description:
  Crypt::OpenSSL::Random provides the ability to seed and query the OpenSSL
  library's pseudo-random number generator


pkgId: 0fddc6d8810f0abd5d720b07c416dff0275daf7e8a1305ee809ef9bbe5f47ede
name: perl-Crypt-RC4
arch: src
version: 2.02
epoch: 0
release: 8.1.1
summary: Perl implementation of the RC4 encryption algorithm
url: http://search.cpan.org/dist/Crypt-RC4/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-RC4-2.02-8.1.1.src.rpm
checksum_type: sha256
description:
  A simple implementation of the RC4 algorithm, developed by RSA Security, Inc.
  Here is the description from RSA's website:

  RC4 is a stream cipher designed by Rivest for RSA Data Security (now RSA
  Security). It is a variable key-size stream cipher with byte-oriented
  operations. The algorithm is based on the use of a random permutation. Analysis
  shows that the period of the cipher is overwhelmingly likely to be greater than
  10100. Eight to sixteen machine operations are required per output byte, and
  the cipher can be expected to run very quickly in software. Independent
  analysts have scrutinized the algorithm and it is considered secure.


pkgId: 45787e43d1feaa15fa7c039e826f64590f57d53f3c580ee386a2584e4a6b15b3
name: perl-Crypt-Rijndael
arch: src
version: 1.09
epoch: 0
release: 13.1.1
summary: Crypt::CBC compliant Rijndael encryption module
url: http://search.cpan.org/dist/Crypt-Rijndael/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-Rijndael-1.09-13.1.1.src.rpm
checksum_type: sha256
description:
  This module implements the Rijndael cipher, which has just been selected as
  the Advanced Encryption Standard.

  Authors:
  --------
      Rafael R. Sevilla
      brian d foy, <bdfoy@cpan.org>


pkgId: 2a2600adb6fcc4894ecb9456f52c8270c1c3f2238358aadd618943279b3d5907
name: perl-Crypt-SSLeay
arch: src
version: 0.58
epoch: 0
release: 14.1.1
summary: OpenSSL support for LWP
url: http://search.cpan.org/dist/Crypt-SSLeay/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-SSLeay-0.58-14.1.1.src.rpm
checksum_type: sha256
description:
  This Perl module provides support for the HTTPS protocol under LWP, to
  allow an 'LWP::UserAgent' object to perform GET, HEAD and POST requests.
  Please see LWP for more information on POST requests.

  The 'Crypt::SSLeay' package provides 'Net::SSL', which is loaded by
  'LWP::Protocol::https' for https requests and provides the necessary SSL
  glue.

  This distribution also makes following deprecated modules available:

      Crypt::SSLeay::CTX
      Crypt::SSLeay::Conn
      Crypt::SSLeay::X509

  Work on Crypt::SSLeay has been continued only to provide https support for
  the LWP (libwww-perl) libraries.

  Authors:
  --------
      This module was originally written by Gisle Aas, and was subsequently
      maintained by Joshua Chamas, David Landgren, brian d foy and Sinan Unur.


pkgId: 74e344fbbdc22481702f06c8177eeddc80e350b8a998ab31b5814e9df95befe3
name: perl-Crypt-SaltedHash
arch: src
version: 0.06
epoch: 0
release: 9.1.1
summary: Perl interface to functions that assist in working with salted hashes
url: http://search.cpan.org/dist/Crypt-SaltedHash/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-SaltedHash-0.06-9.1.1.src.rpm
checksum_type: sha256
description:
  The Crypt::SaltedHash module provides an object oriented interface to
  create salted (or seeded) hashes of clear text data. The original
  formalization of this concept comes from RFC-3112 and is extended by the
  use of different digital agorithms.


pkgId: 826f0cbbe1316906eb3719d6c710521803023bb269f6b968df2e75138a7db4c3
name: perl-Crypt-SmbHash
arch: src
version: 0.12
epoch: 0
release: 151.1.1
summary: perl module Crypt::SmbHash
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Crypt-SmbHash-0.12-151.1.1.src.rpm
checksum_type: sha256
description:
  This module provides functions to generate LM/NT hashes as used by
  Samba



  Authors:
  --------
      Benjamin Kuit <bj@it.uts.edu.au>


pkgId: 3341706ed801904fdebda9e139879a10ebbf85142b6b1f039fca22fb648af618
name: perl-Curses
arch: src
version: 1.28
epoch: 0
release: 19.1.1
summary: Terminal screen handling and optimization
url: http://cpan.org/modules/by-module/Curses/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Curses-1.28-19.1.1.src.rpm
checksum_type: sha256
description:
  Curses is the interface between Perl and your system's curses(3) library.
  For descriptions on the usage of a given function, variable, or constant,
  consult your system's documentation, as such information invariably varies
  (:-) between different curses(3) libraries and operating systems. This
  document describes the interface itself, and assumes that you already know
  how your system's curses(3) library works.


pkgId: 6467a0750c860a558142bbef57e547a621de2d34b343ecea42921e4a4e95aac6
name: perl-CursesWidgets
arch: src
version: 1.997
epoch: 0
release: 159.1.1
summary: CursesWidgets Perl module
url: http://search.cpan.org/dist/CursesWidgets/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-CursesWidgets-1.997-159.1.1.src.rpm
checksum_type: sha256
description:
  NOTE:  This is **NOT** backwards compatible with the pre-1.99 versions.
         This is entirely OO-based, hence any older scripts relying on the
         old versions will need to be rewritten.


pkgId: 2482eb09ed48427242807e05551f361f1a478c022161c2585ace71e6ab29164c
name: perl-DBD-CSV
arch: src
version: 0.34
epoch: 0
release: 4.1.1
summary: DBI driver for CSV files
url: http://search.cpan.org/dist/DBD-CSV/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBD-CSV-0.34-4.1.1.src.rpm
checksum_type: sha256
description:
  The DBD::CSV module is yet another driver for the DBI (Database independent
  interface for Perl). This one is based on the SQL "engine" SQL::Statement
  and the abstract DBI driver DBD::File and implements access to so-called
  CSV files (Comma Separated Values). Such files are often used for exporting
  MS Access and MS Excel data.

  See the DBI manpage for details on DBI, the SQL::Statement manpage for
  details on SQL::Statement and the DBD::File manpage for details on the base
  class DBD::File.


pkgId: 59476dc6e57f9ef72bf498f216f1e0db08a4e503a8001d64bf1454fa6411b507
name: perl-DBD-ODBC
arch: src
version: 1.33
epoch: 0
release: 7.1.1
summary: ODBC Driver for DBI
url: http://search.cpan.org/dist/DBD-ODBC/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBD-ODBC-1.33-7.1.1.src.rpm
checksum_type: sha256
description:
  This module is needed to access ODBC databases from within Perl. The
  module uses the unixODBC manager to connect to the database.


pkgId: dfcff95100480a7fd071730541192834f467cd853c8700aef59fbd84659b7731
name: perl-DBD-SQLite
arch: src
version: 1.37
epoch: 0
release: 2.1.1
summary: Self-contained RDBMS in a DBI Driver
url: http://search.cpan.org/dist/DBD-SQLite/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBD-SQLite-1.37-2.1.1.src.rpm
checksum_type: sha256
description:
  SQLite is a small fast embedded SQL database engine.

  DBD::SQLite embeds that database engine into a DBD driver, so
  if you want a relational database for your project, but don`t
  want to install a large RDBMS system like MySQL or PostgreSQL,
  then DBD::SQLite may be just what you need.

  It supports quite a lot of features, such as transactions (atomic
  commit and rollback), indexes, DBA-free operation, a large subset
  of SQL92 supported, and more.


pkgId: ccee98380b0b9e3c4a4977c7d09533a59e34e4a29698c230f0f62561c8ec48cc
name: perl-DBD-XBase
arch: src
version: 1.03
epoch: 0
release: 8.1.1
summary: Provides Access to XBase Files
url: http://cpan.org/modules/by-module/DBD/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBD-XBase-1.03-8.1.1.src.rpm
checksum_type: sha256
description:
  Module XBase provides access to XBase (dBase, Fox*) database files,
  namely dbf, dbt, fpt, ndx, ntx, mdx, idx and cdx.

  Authors:
  --------
      Jan Pazdziora <adelton@fi.muni.cz>


pkgId: 1474be463704f46936a6e57dce288080db64a1a81b78967adfdc977b403207f7
name: perl-DBD-mysql
arch: src
version: 4.021
epoch: 0
release: 4.1.1
summary: MySQL driver for the Perl5 Database Interface (DBI)
url: http://search.cpan.org/dist/DBD-mysql/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBD-mysql-4.021-4.1.1.src.rpm
checksum_type: sha256
description:
  DBD::mysql is the Perl5 Database Interface driver for the MySQL database.
  In other words: DBD::mysql is an interface between the Perl programming
  language and the MySQL programming API that comes with the MySQL relational
  database management system. Most functions provided by this programming API
  are supported. Some rarely used functions are missing, mainly because noone
  ever requested them. :-)


pkgId: 8f7736cb4d7fe63e1237189fb91d192a34d825cef9d3a0122996fa68d1eafcb4
name: perl-DBI
arch: src
version: 1.617
epoch: 0
release: 4.1.1
summary: Database independent interface for Perl
url: http://search.cpan.org/dist/DBI/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBI-1.617-4.1.1.src.rpm
checksum_type: sha256
description:
  The DBI is a database access module for the Perl programming language.
  It defines a set of methods, variables, and conventions that provide a
  consistent database interface, independent of the actual database
  being used.


pkgId: 81c02461ec148ae8bb05a90767a4006b0099878ce1fa34067edd7f45abc10142
name: perl-DBIx-Class
arch: src
version: 0.08196
epoch: 0
release: 4.1.1
summary: Extensible and flexible object <-> relational mapper.
url: http://search.cpan.org/dist/DBIx-Class/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBIx-Class-0.08196-4.1.1.src.rpm
checksum_type: sha256
description:
  This is an SQL to OO mapper with an object API inspired by the Class::DBI
  manpage (with a compatibility layer as a springboard for porting) and a
  resultset API that allows abstract encapsulation of database operations. It
  aims to make representing queries in your code as perl-ish as possible
  while still providing access to as many of the capabilities of the database
  as possible, including retrieving related records from multiple tables in a
  single query, JOIN, LEFT JOIN, COUNT, DISTINCT, GROUP BY, ORDER BY and
  HAVING support.

  DBIx::Class can handle multi-column primary and foreign keys, complex
  queries and database-level paging, and does its best to only query the
  database in order to return something you've directly asked for. If a
  resultset is used as an iterator it only fetches rows off the statement
  handle as requested in order to minimise memory usage. It has
  auto-increment support for SQLite, MySQL, PostgreSQL, Oracle, SQL Server
  and DB2 and is known to be used in production on at least the first four,
  and is fork- and thread-safe out of the box (although
  DBI/Threads_and_Thread_Safety).

  This project is still under rapid development, so large new features may be
  marked EXPERIMENTAL - such APIs are still usable but may have edge bugs.
  Failing test cases are *always* welcome and point releases are put out
  rapidly as bugs are found and fixed.

  We do our best to maintain full backwards compatibility for published APIs,
  since DBIx::Class is used in production in many organisations, and even
  backwards incompatible changes to non-published APIs will be fixed if
  they're reported and doing so doesn't cost the codebase anything.

  The test suite is quite substantial, and several developer releases are
  generally made to CPAN before the branch for the next release is merged
  back to trunk for a major release.


pkgId: 66b06ee8c37e4ebdf77f9e3818f8a78f18b199671c20246a62a08036741223c3
name: perl-DBIx-Class-IntrospectableM2M
arch: src
version: 0.001001
epoch: 0
release: 4.1.1
summary: Introspect many-to-many shortcuts
url: http://search.cpan.org/dist/DBIx-Class-IntrospectableM2M/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBIx-Class-IntrospectableM2M-0.001001-4.1.1.src.rpm
checksum_type: sha256
description:
  Because the many-to-many relationships are not real relationships, they can
  not be introspected with DBIx::Class. Many-to-many relationships are
  actually just a collection of convenience methods installed to bridge two
  relationships. This the DBIx::Class manpage component can be used to store
  all relevant information about these non-relationships so they can later be
  introspected and examined.


pkgId: 7193e2455498c9eb89eb9aab5e9673dc636c3c4206c6fb7f889b9fad082039f5
name: perl-DBIx-Simple
arch: src
version: 1.35
epoch: 0
release: 4.1.1
summary: Very complete easy-to-use OO interface to DBI
url: http://search.cpan.org/dist/DBIx-Simple/
rpm_license: MIT
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBIx-Simple-1.35-4.1.1.src.rpm
checksum_type: sha256
description:
  DBIx::Simple provides a simplified interface to DBI, Perl's powerful
  database module.

  This module is aimed at rapid development and easy maintenance. Query
  preparation and execution are combined in a single method, the result
  object (which is a wrapper around the statement handle) provides easy
  row-by-row and slurping methods.

  The 'query' method returns either a result object, or a dummy object. The
  dummy object returns undef (or an empty list) for all methods and when used
  in boolean context, is false. The dummy object lets you postpone (or skip)
  error checking, but it also makes immediate error checking simply
  '$db->query(...) or die $db->error'.


pkgId: ef50fd235a6cd9fc6fb013e7400845b44b10ea3355662b3ba16435b816b1bc2e
name: perl-DBIx-Transaction
arch: src
version: 1.100
epoch: 0
release: 17.1.1
summary: Allow transactions to be nested in DBI
url: http://cpan.org/modules/by-module/DBIx/
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBIx-Transaction-1.100-17.1.1.src.rpm
checksum_type: sha256
description:
  DBIx::Transaction is a wrapper around DBI that helps you manage your
  database transactions.



  Authors:
  --------
      Tyler "Crackerjack" MacDonald <japh@crackerjack.net>


pkgId: 645a610cb0cd9817efa9a6d0476d679f2bfa5b04d5c0aae23feecb642be31c08
name: perl-DBM-Deep
arch: src
version: 2.0004
epoch: 0
release: 6.1.1
summary: Pure perl multi-level hash/array DBM that supports transactions
url: http://search.cpan.org/dist/DBM-Deep/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DBM-Deep-2.0004-6.1.1.src.rpm
checksum_type: sha256
description:
  A unique flat-file database module, written in pure perl. True multi-level
  hash/array support (unlike MLDBM, which is faked), hybrid OO / tie()
  interface, cross-platform FTPable files, ACID transactions, and is quite
  fast. Can handle millions of keys and unlimited levels without significant
  slow-down. Written from the ground-up in pure perl -- this is NOT a
  wrapper around a C-based DBM. Out-of-the-box compatibility with Unix, Mac
  OS X and Windows.

  Author:
  -------
      Rob Kinyon, <rkinyon@cpan.org>
      Joseph Huckaby, <jhuckaby@cpan.org>


pkgId: b64b99bf0bca99a2dd31a0331dbbd5d4156523f276884a7f0104a04409b36c5a
name: perl-Data-Alias
arch: src
version: 1.16
epoch: 0
release: 5.1.1
summary: Comprehensive set of aliasing operations
url: http://search.cpan.org/dist/Data-Alias/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Alias-1.16-5.1.1.src.rpm
checksum_type: sha256
description:
  Aliasing is the phenomenon where two different expressions actually refer
  to the same thing. Modifying one will modify the other, and if you take a
  reference to both, the two values are the same.

  Aliasing occurs in Perl for example in for-loops and sub-calls:

      for $var ($x) {
              
      }

      foo($y);
      sub foo {
              
      }

  Data::Alias is a module that allows you to apply "aliasing semantics" to a
  section of code, causing aliases to be made whereever Perl would normally
  make copies instead. You can use this to improve efficiency and
  readability, when compared to using references.

  The exact details of aliasing semantics are below under the /DETAILS
  manpage.


pkgId: 0a2903f8903d8a64a034e02f8382857890be11ca798b8d4b1eee326f3fdba653
name: perl-Data-Compare
arch: src
version: 1.22
epoch: 0
release: 4.1.1
summary: Compare perl data structures
url: http://search.cpan.org/dist/Data-Compare/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Compare-1.22-4.1.1.src.rpm
checksum_type: sha256
description:
  Compare two perl data structures recursively. Returns 0 if the structures
  differ, else returns 1.

  A few data types are treated as special cases:

  * Scalar::Properties objects

    This has been moved into a plugin, although functionality remains the
    same as with the previous version. Full documentation is in the
    Data::Compare::Plugins::Scalar::Properties manpage.

  * Compiled regular expressions, eg qr/foo/

    These are stringified before comparison, so the following will match:

        $r = qr/abc/i;
        $s = qr/abc/i;
        Compare($r, $s);

    and the following won't, despite them matching *exactly* the same text:

        $r = qr/abc/i;
        $s = qr/[aA][bB][cC]/;
        Compare($r, $s);

    Sorry, that's the best we can do.

  * CODE and GLOB references

    These are assumed not to match unless the references are identical - ie,
    both are references to the same thing.

  You may also customise how we compare structures by supplying options in a
  hashref as a third parameter to the 'Compare()' function. This is not yet
  available through the OO-ish interface. These options will be in force for
  the *whole* of your comparison, so will apply to structures that are
  lurking deep down in your data as well as at the top level, so beware!

  * ignore_hash_keys

    an arrayref of strings. When comparing two hashes, any keys mentioned in
    this list will be ignored.


pkgId: b89feb57f4fe0453c3954a12613369a0dbaf006b994674c43d4f713a32a0c5ea
name: perl-Data-Dump
arch: src
version: 1.21
epoch: 0
release: 5.1.1
summary: Pretty printing of data structures
url: http://search.cpan.org/dist/Data-Dump
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Dump-1.21-5.1.1.src.rpm
checksum_type: sha256
description:
  This module provides functions that take a list of values as their
  argument and produce a string as their result. The string contains Perl
  code that, when "eval"ed, produces a deep copy of the original
  arguments.




  Authors:
  --------
      Gisle Aas <gisle@aas.no>


pkgId: 5c7c0c7c290c0783e17de64c29b2f34e47037868aa8768456983ff39426b4b57
name: perl-Data-Dump-Streamer
arch: src
version: 2.33
epoch: 0
release: 4.1.1
summary: Accurately serialize a data structure as Perl code.
url: http://search.cpan.org/dist/Data-Dump-Streamer/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Dump-Streamer-2.33-4.1.1.src.rpm
checksum_type: sha256
description:
  Given a list of scalars or reference variables, writes out their contents
  in perl syntax. The references can also be objects. The contents of each
  variable is output using the least number of Perl statements as convenient,
  usually only one. Self-referential structures, closures, and objects are
  output correctly.

  The return value can be evaled to get back an identical copy of the
  original reference structure. In some cases this may require the use of
  utility subs that Data::Dump::Streamer will optionally export.

  This module is very similar in concept to the core module Data::Dumper,
  with the major differences being that this module is designed to output to
  a stream instead of constructing its output in memory (trading speed for
  memory), and that the traversal over the data structure is effectively
  breadth first versus the depth first traversal done by the others.

  In fact the data structure is scanned twice, first in breadth first mode to
  perform structural analysis, and then in depth first mode to actually
  produce the output, but obeying the depth relationships of the first pass.


pkgId: e200833fa53b5227ebcb22f42617a7de54e98cacdbfd6826fcc3bccc1f7de84f
name: perl-Data-Dumper-Concise
arch: src
version: 2.020
epoch: 0
release: 4.1.1
summary: Less indentation and newlines plus sub deparsing
url: http://search.cpan.org/dist/Data-Dumper-Concise/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Dumper-Concise-2.020-4.1.1.src.rpm
checksum_type: sha256
description:
  This module always exports a single function, Dumper, which can be called
  with an array of values to dump those values.

  It exists, fundamentally, as a convenient way to reproduce a set of Dumper
  options that we've found ourselves using across large numbers of
  applications, primarily for debugging output.

  The principle guiding theme is "all the concision you can get while still
  having a useful dump and not doing anything cleverer than setting
  Data::Dumper options" - it's been pointed out to us that
  Data::Dump::Streamer can produce shorter output with less lines of code. We
  know. This is simpler and we've never seen it segfault. But for
  complex/weird structures, it generally rocks. You should use it as well,
  when Concise is underkill. We do.

  Why is deparsing on when the aim is concision? Because you often want to
  know what subroutine refs you have when debugging and because if you were
  planning to eval this back in you probably wanted to remove subrefs first
  and add them back in a custom way anyway. Note that this -does- force using
  the pure perl Dumper rather than the XS one, but I've never in my life seen
  Data::Dumper show up in a profile so "who cares?".


pkgId: e30984130a71be1faa2768762db9e0bd91acfae1690981b7e311fca325e11c84
name: perl-Data-Hexify
arch: src
version: 1.00
epoch: 0
release: 10.1.1
summary: Perl extension for hexdumping arbitrary data
url: http://search.cpan.org/dist/Data-Hexify/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Hexify-1.00-10.1.1.src.rpm
checksum_type: sha256
description:
  This module exports one subroutine: 'Hexify'.

  'Hexify' formats arbitrary (possible binary) data into a format suitable
  for hex dumps in the style of 'xd' or 'hexl'.

  The first, or only, argument to 'Hexify' contains the data, or a reference
  to the data, to be hexified. Hexify will return a string that prints as
  follows:

    0000: 70 61 63 6b 61 67 65 20 44 61 74 61 3a 3a 48 65  package Data::He
    0010: 78 69 66 79 3b 0a 0a 75 73 65 20 35 2e 30 30 36  xify;..use 5.006

  and so on. At the left is the (hexadecimal) index of the data, then a
  number of hex bytes, followed by the chunk of data with unprintables
  replaced by periods.

  The optional second argument to 'Hexify' must be a hash or a hash
  reference, containing values for any of the following parameters:

  * first

    The first byte of the data to be processed. Default is to start from the
    beginning of the data.

  * length

    The number of bytes to be processed. Default is to proceed all data.

  * chunk

    The number of bytes to be processed per line of output. Default is 16.

  * group

    The number of bytes to be grouped together. Default is 1 (no grouping).
    If used, it must be a divisor of the chunk size.

  * duplicates

    When set, duplicate lines of output are suppressed and replaced by a
    single line reading '**SAME**'.

    Duplicate suppression is enabled by default.

  * showdata

    A reference to a subroutine that is used to produce a printable string
    from a chunk of data. By default, a subroutine is used that replaces
    unwanted bytes by periods.

    The subroutine gets the chunk of data passed as argument, and should
    return a printable string of at most 'chunksize' characters.

  * align

    Align the result to 'chunksize' bytes. This is relevant only when
    processing data not from the beginning. For example, when 'first' is 10,
    the result would become:

      0000:                ...    74 61 3a 3a 48 65            ta::He
      0010: 78 69 66 79 3b ... 65 20 35 2e 30 30 36  xify;..use 5.006
      ... and so on ...

    Alignment is on by default. Without alignment, the result would be:

      000a: 74 61 3a 3a 48 ... 79 3b 0a 0a 75 73 65  ta::Hexify;..use
      001a: 20 35 2e 30 30 ... 73 65 20 73 74 72 69   5.006;.use stri
      ... and so on ...

  * start

    Pretend that the data started at this byte (while in reality it starts at
    byte 'first'). The above example, with 'start => 0', becomes:

      0000: 74 61 3a 3a 48 ... 79 3b 0a 0a 75 73 65  ta::Hexify;..use
      0010: 20 35 2e 30 30 ... 73 65 20 73 74 72 69   5.006;.use stri
      ... and so on ...


pkgId: 01b2f11bdb509dc0952383f9ffebf8a9eee19e6e1bfdc5baa4475c0a00bdc832
name: perl-Data-Hierarchy
arch: src
version: 0.34
epoch: 0
release: 126.1.1
summary: Handle data in a hierarchical structure
url: http://search.cpan.org/dist/Data-Hierarchy/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Hierarchy-0.34-126.1.1.src.rpm
checksum_type: sha256
description:
  the Data::Hierarchy manpage provides a simple interface for manipulating
  inheritable data attached to a hierarchical environment (like a
  filesystem).

  One use of the Data::Hierarchy manpage is to allow an application to
  annotate paths in a real filesystem in a single compact data structure.
  However, the hierarchy does not actually need to correspond to an actual
  filesystem.

  Paths in a hierarchy are referred to in a Unix-like syntax; '"/"' is the
  root "directory". (You can specify a different separator character than the
  slash when you construct a Data::Hierarchy object.) With the exception of
  the root path, paths should never contain trailing slashes. You can
  associate properties, which are arbitrary name/value pairs, with any path.
  (Properties cannot contain the undefined value.) By default, properties are
  inherited by child paths: thus, if you store some data at '/some/path':

      $tree->store('/some/path', {color => 'red'});

  you can fetch it again at a '/some/path/below/that':

      print $tree->get('/some/path/below/that')->{'color'};
      

  On the other hand, properties whose names begin with dots are uninherited,
  or "sticky":

      $tree->store('/some/path', {'.color' => 'blue'});
      print $tree->get('/some/path')->{'.color'};            # prints blue
      print $tree->get('/some/path/below/that')->{'.color'}; # undefined

  Note that you do not need to (and in fact, cannot) explicitly add "files"
  or "directories" to the hierarchy; you simply add and delete properties to
  paths.


pkgId: 4a3f16d4241d619e6397a62cf6172ab04d3dd0798c85ae8ea2e7e7b42c4115c3
name: perl-Data-OptList
arch: src
version: 0.107
epoch: 0
release: 10.1.1
summary: Parse and validate simple name/value option pairs
url: http://search.cpan.org/dist/Data-OptList
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-OptList-0.107-10.1.1.src.rpm
checksum_type: sha256
description:
  Hashes are great for storing named data, but if you want more than one
  entry for a name, you have to use a list of pairs. Even then, this is
  really boring to write:

    $values = [
      foo => undef,
      bar => undef,
      baz => undef,
      xyz => { ... },
    ];

  Just look at all those undefs! Don't worry, we can get rid of those:

    $values = [
      map { $_ => undef } qw(foo bar baz),
      xyz => { ... },
    ];

  Aaaauuugh! We've saved a little typing, but now it requires thought to
  read, and thinking is even worse than typing.

  With Data::OptList, you can do this instead:

    $values = Data::OptList::mkopt([
      qw(foo bar baz),
      xyz => { ... },
    ]);

  This works by assuming that any defined scalar is a name and any
  reference following a name is its value.


pkgId: 77588d023c2003f81af78cdd0190677bc7d1b42df0ebcd3d54b88c355f32f207
name: perl-Data-Page
arch: src
version: 2.02
epoch: 0
release: 4.1.1
summary: Help when paging through sets of results
url: http://search.cpan.org/dist/Data-Page/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Page-2.02-4.1.1.src.rpm
checksum_type: sha256
description:
  When searching through large amounts of data, it is often the case that a
  result set is returned that is larger than we want to display on one page.
  This results in wanting to page through various pages of data. The maths
  behind this is unfortunately fiddly, hence this module.

  The main concept is that you pass in the number of total entries, the number
  of entries per page, and the current page number. You can then call methods
  to find out how many pages of information there are, and what number the
  first and last entries on the current page really are.


pkgId: 51e220d6647f5cc9608942710cdbf1a5f5cc389370fdfe0a53ecaac12277b033
name: perl-Data-Peek
arch: src
version: 0.37
epoch: 0
release: 4.1.1
summary: A collection of low-level debug facilities
url: http://search.cpan.org/dist/Data-Peek/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Peek-0.37-4.1.1.src.rpm
checksum_type: sha256
description:
  Data::Peek started off as 'DDumper' being a wrapper module over the
  Data::Dumper manpage, but grew out to be a set of low-level data
  introspection utilities that no other module provided yet, using the lowest
  level of the perl internals API as possible.


pkgId: cdb5bda9c999d44a9c6cac0d8b57c55a32a0ffa938d888ff3de1ad34702f2c08
name: perl-Data-Section
arch: src
version: 0.101621
epoch: 0
release: 5.1.1
summary: Read multiple hunks of data out of your DATA section
url: http://search.cpan.org/dist/Data-Section/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Section-0.101621-5.1.1.src.rpm
checksum_type: sha256
description:
  Data::Section provides an easy way to access multiple named chunks of line-
  oriented data in your module's DATA section. It was written to allow
  modules to store their own templates, but probably has other uses.

  Authors:
  --------
      Ricardo SIGNES <rjbs@cpan.org>


pkgId: 680d9bcf9cff85a71b1a765fa9c83ad83247771a26df86951f60d0159e5e13fb
name: perl-Data-ShowTable
arch: src
version: 3.3
epoch: 0
release: 727.1.1
summary: A Perl Module that allows Pretty-Printing of Data Arrays
url: http://search.cpan.org/perldoc?Data::ShowTable
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-ShowTable-3.3-727.1.1.src.rpm
checksum_type: sha256
description:
  ShowTable.pm is a Perl 5 module which defines subroutines to print
  arrays of data in nicely formatted listings. It uses one of four
  possible formats: simple table, boxed table, list style, and
  HTML-formatting.



  Authors:
  --------
      Alan K. Stebbens <aks@sgi.com>


pkgId: 21063192caf4a97f03191e59248d3b6ad024407538f80925dd5279e99cbb29c7
name: perl-Data-Util
arch: src
version: 0.59
epoch: 0
release: 5.1.1
summary: A selection of utilities for data and data types
url: http://search.cpan.org/dist/Data-Util/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Util-0.59-5.1.1.src.rpm
checksum_type: sha256
description:
  This module provides utility functions for data and data types, including
  functions for subroutines and symbol table hashes (stashes).

  The implementation of this module is both Pure Perl and XS, so if you have
  a C compiler, all the functions this module provides are really faster.

  There are many benchmarks in the _DIST-DIR/benchmark/_ directory.


pkgId: 568442096bd56784b35b89fefc93606016e9c11dc3db538a859466562d681d67
name: perl-Data-Visitor
arch: src
version: 0.28
epoch: 0
release: 4.1.1
summary: Visitor style traversal of Perl data structures
url: http://search.cpan.org/dist/Data-Visitor/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Data-Visitor-0.28-4.1.1.src.rpm
checksum_type: sha256
description:
  This module is a simple visitor implementation for Perl values.

  It has a main dispatcher method, 'visit', which takes a single perl value
  and then calls the methods appropriate for that value.

  It can recursively map (cloning as necessary) or just traverse most
  structures, with support for per object behavior, circular structures,
  visiting tied structures, and all ref types (hashes, arrays, scalars, code,
  globs).

  the Data::Visitor manpage is meant to be subclassed, but also ships with a
  callback driven subclass, the Data::Visitor::Callback manpage.


pkgId: 7f182caefcf7fc2f23421493589bba39090978c08e827174a63a5ee973b6dadc
name: perl-Date-Calc
arch: src
version: 6.3
epoch: 0
release: 17.1.1
summary: Perl Date-Calc Module
url: http://cpan.org/modules/by-module/Date
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Date-Calc-6.3-17.1.1.src.rpm
checksum_type: sha256
description:
  This package consists of a C library and a Perl module (which uses the
  C library, internally) for all kinds of date calculations based on the
  Gregorian calendar (the one used in all western countries today),
  thereby complying with all relevant norms and standards: ISO/R
  2015-1971, DIN 1355 and, to some extent, ISO 8601 (where applicable).

  (See also http://www.engelschall.com/u/sb/download/Date-Calc/DIN1355/
  for a scan of part of the "DIN 1355" document (in German)).

  The module of course handles year numbers of 2000 and above correctly
  ("Year 2000" or "Y2K" compliance) -- actually all year numbers from 1
  to the largest positive integer representable on your system (which is
  at least 32767) can be dealt with.

  Note that this package EXTRAPOLATES the Gregorian calendar BACK until
  the year 1 A.D. -- even though the Gregorian calendar was only adopted
  in 1582 by most (not all) European countries, in obedience to the
  corresponding decree of catholic pope Gregor I in that year.

  Some (mainly protestant) countries continued to use the Julian calendar
  (used until then) until as late as the beginning of the 20th century.

  Finally, note that this package is not intended to do everything you
  could ever imagine automagically for you; it is rather intended to
  serve as a toolbox (in the best of UNIX spirit and traditions) which
  should, however, always get you where you want to go.



  Authors:
  --------
      Steffen Beyer <sb@engelschall.com>


pkgId: 2e69c11adc8e4170699d39ec3a188cb078f1f134e62c98b138607baed350d370
name: perl-Date-Manip
arch: src
version: 6.31
epoch: 0
release: 4.1.1
summary: Date manipulation routines
url: http://search.cpan.org/dist/Date-Manip/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Date-Manip-6.31-4.1.1.src.rpm
checksum_type: sha256
description:
  Date::Manip is a series of modules designed to make any common date/time
  operation easy to do. Operations such as comparing two times, determining a
  data a given amount of time from another, or parsing international times
  are all easily done. It deals with time as it is used in the Gregorian
  calendar (the one currently in use) with full support for time changes due
  to daylight saving time.

  From the very beginning, the main focus of Date::Manip has been to be able
  to do ANY desired date/time operation easily. Many other modules exist
  which may do a subset of these operations quicker or more efficiently, but
  no other module can do all of the operations available in Date::Manip.

  Since many other date/time modules exist, some of which may do the specific
  operation(s) you need faster, be sure to read the section SHOULD I USE
  DATE::MANIP in the Date::Manip::Misc document before deciding which of the
  Date and Time modules from CPAN is for you. However, if you want one module
  to do it all, Date::Manip is the one to use.


pkgId: de377e3245167f7abdf1932507367232500f546794578c5fc9c7c585409fa05c
name: perl-Date-Simple
arch: src
version: 3.03
epoch: 0
release: 4.1.1
summary: a simple date object
url: http://search.cpan.org/dist/Date-Simple/
rpm_license: Artistic-1.0 or GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Date-Simple-3.03-4.1.1.src.rpm
checksum_type: sha256
description:
  Dates are complex enough without times and timezones. This module may be
  used to create simple date objects. It handles:

  * Validation.

    Reject 1999-02-29 but accept 2000-02-29.

  * Interval arithmetic.

    How many days were between two given dates? What date comes N days after
    today?

  * Day-of-week calculation.

    What day of the week is a given date?

  * Transparent date formatting.

    How should a date object be formatted.

  It does *not* deal with hours, minutes, seconds, and time zones.

  A date is uniquely identified by year, month, and day integers within valid
  ranges. This module will not allow the creation of objects for invalid
  dates. Attempting to create an invalid date will return undef. Month
  numbering starts at 1 for January, unlike in C and Java. Years are 4-digit.

  Gregorian dates up to year 9999 are handled correctly, but we rely on
  Perl's builtin 'localtime' function when the current date is requested. On
  some platforms, 'localtime' may be vulnerable to rollovers such as the Unix
  'time_t' wraparound of 18 January 2038.

  Overloading is used so you can compare or subtract two dates using standard
  numeric operators such as '==', and the sum of a date object and an integer
  is another date object.

  Date::Simple objects are immutable. After assigning '$date1' to '$date2',
  no change to '$date1' can affect '$date2'. This means, for example, that
  there is nothing like a 'set_year' operation, and '$date++' assigns a new
  object to '$date'.

  This module contains various undocumented functions. They may not be
  available on all platforms and are likely to change or disappear in future
  releases. Please let the author know if you think any of them should be
  public.


pkgId: f06981e8c4773ed65007fb38c60014c3b9c143a1e5b7c9ac5b30215b56e5f291
name: perl-Date-Tiny
arch: src
version: 1.04
epoch: 0
release: 4.1.1
summary: A date object with as little code as possible
url: http://search.cpan.org/perldoc?Date::Tiny
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Date-Tiny-1.04-4.1.1.src.rpm
checksum_type: sha256
description:
  Date::Tiny is a member of the DateTime::Tiny suite of time modules.

  It implements an extremely lightweight object that represents a date, without
  any time data.


pkgId: 243a6e538f42c2b3ab78900a20254e9b31863786789b88b29f8b58377f5a8253
name: perl-DateTime
arch: src
version: 0.72
epoch: 0
release: 5.1.1
summary: A date and time object
url: http://search.cpan.org/dist/DateTime/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-0.72-5.1.1.src.rpm
checksum_type: sha256
description:
  DateTime is a class for the representation of date/time combinations, and
  is part of the Perl DateTime project. For details on this project please
  see the http://datetime.perl.org/ manpage. The DateTime site has a FAQ
  which may help answer many "how do I do X?" questions. The FAQ is at the
  http://datetime.perl.org/wiki/datetime/page/FAQ manpage.

  It represents the Gregorian calendar, extended backwards in time before its
  creation (in 1582). This is sometimes known as the "proleptic Gregorian
  calendar". In this calendar, the first day of the calendar (the epoch), is
  the first day of year 1, which corresponds to the date which was
  (incorrectly) believed to be the birth of Jesus Christ.

  The calendar represented does have a year 0, and in that way differs from
  how dates are often written using "BCE/CE" or "BC/AD".

  For infinite datetimes, please see the DateTime::Infinite module.


pkgId: a54d16024d47725c3bf20628c6895355714a0785d71a789a6e779b8913e43698
name: perl-DateTime-Calendar-Mayan
arch: src
version: 0.0601
epoch: 0
release: 14.1.1
summary: The Mayan Long Count, Haab, and Tzolkin calendars
url: http://search.cpan.org/perldoc?DateTime::Calendar::Mayan
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Calendar-Mayan-0.0601-14.1.1.src.rpm
checksum_type: sha256
description:
  An implementation of the Mayan Long Count, Haab, and Tzolkin calendars as
  defined in "Calendrical Calculations The Millennium Edition". Supplemented by
  "Frequently Asked Questions about Calendars".

  Author:
  -------
      Joshua Hoblitt <jhoblitt@cpan.org>


pkgId: 08b04ddfd44050d300ea21ba2360724ec789a953d71f25837cfad2c9f98a4df3
name: perl-DateTime-Format-Builder
arch: src
version: 0.80
epoch: 0
release: 9.1.2
summary: Create DateTime parser classes and objects
url: http://search.cpan.org/perldoc?DateTime::Format::Builder
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Format-Builder-0.80-9.1.2.src.rpm
checksum_type: sha256
description:
  DateTime::Format::Builder creates DateTime parsers. Many string formats of
  dates and times are simple and just require a basic regular expression to
  extract the relevant information. Builder provides a simple way to do this
  without writing reams of structural code.

  Builder provides a number of methods, most of which you'll never need, or at
  least rarely need. They're provided more for exposing of the module's innards
  to any subclasses, or for when you need to do something slightly beyond what I
  expected.

  Author:
  -------
      Iain Truskett <spoon@cpan.org>,
      Dave Rolsky <autarch@urth.org>


pkgId: a33782e1f9d5adb3e259587bd5c8650d6009725721f289394f1b4309ec249975
name: perl-DateTime-Format-DateParse
arch: src
version: 0.05
epoch: 0
release: 17.1.1
summary: Parses Date::Parse compatible formats
url: http://search.cpan.org/dist/DateTime-Format-DateParse
rpm_license: GPL-2.0 or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Format-DateParse-0.05-17.1.1.src.rpm
checksum_type: sha256
description:
  This module is a compatibility wrapper around Date::Parse.

    Author:	Joshua Hoblitt (JHOBLITT) <jhoblitt@cpan.org>


pkgId: 1910fe0b323a8d91ec9b6ea948e06be11eebe6f294e1a13e9e40d7752cd6596d
name: perl-DateTime-Format-MySQL
arch: src
version: 0.04
epoch: 0
release: 9.1.1
summary: Parse and format MySQL dates and times
url: http://search.cpan.org/dist/DateTime-Format-MySQL/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Format-MySQL-0.04-9.1.1.src.rpm
checksum_type: sha256
description:
  This module understands the formats used by MySQL for its DATE, DATETIME,
  TIME, and TIMESTAMP data types. It can be used to parse these formats in
  order to create DateTime objects, and it can take a DateTime object and
  produce a string representing it in the MySQL format.


pkgId: 60ca6ee27bce5f89510b3074908d05326985866c9c59fefd092d81fe2273b592
name: perl-DateTime-Format-Strptime
arch: src
version: 1.5000
epoch: 0
release: 9.1.1
summary: Parse and format strp and strf time patterns
url: http://search.cpan.org/dist/DateTime-Format-Strptime/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Format-Strptime-1.5000-9.1.1.src.rpm
checksum_type: sha256
description:
  This module implements most of strptime(3), the POSIX function that is the
  reverse of strftime(3), for DateTime. While strftime takes a DateTime and a
  pattern and returns a string, strptime takes a string and a pattern and
  returns the DateTime object associated.

  Authors:
  --------
       Rick Measham <rickm@cpan.org>


pkgId: 23fd915f41609a92fe0e18e946cb16b7356b5b38a0c651014294ddc43ab34e84
name: perl-DateTime-Locale
arch: src
version: 0.45
epoch: 0
release: 18.1.1
summary: Localization support for DateTime.pm
url: http://search.cpan.org/dist/DateTime-Locale/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Locale-0.45-18.1.1.src.rpm
checksum_type: sha256
description:
  DateTime::Locale is primarily a factory for the various locale subclasses.
  It also provides some functions for getting information on all the
  available locales.

  If you want to know what methods are available for locale objects,
  then please read the DateTime::Locale::Base documentation.


pkgId: a3a62143477e0ee8a36a8b612f21db097b1be3ad86474f2d3a6b5ef7519d3dd7
name: perl-DateTime-TimeZone
arch: src
version: 1.42
epoch: 0
release: 6.1.1
summary: Time zone object base class and factory
url: http://search.cpan.org/dist/DateTime-TimeZone/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-TimeZone-1.42-6.1.1.src.rpm
checksum_type: sha256
description:
  This class is the base class for all time zone objects. A time zone is
  represented internally as a set of observances, each of which describes the
  offset from GMT for a given time period.

  Note that without the 'DateTime.pm' module, this module does not do much.
  It's primary interface is through a 'DateTime' object, and most users will
  not need to directly use 'DateTime::TimeZone' methods.


pkgId: 16059e197515dd50c43996a453b34a66650ed97493a447a33e8fbd9c59d9d00e
name: perl-DateTime-Tiny
arch: src
version: 1.04
epoch: 0
release: 4.1.1
summary: A date object, with as little code as possible
url: http://search.cpan.org/dist/DateTime-Tiny/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-DateTime-Tiny-1.04-4.1.1.src.rpm
checksum_type: sha256
description:
  *DateTime::Tiny* is a most prominent member of the the DateTime::Tiny
  manpage suite of time modules.

  It implements an extremely lightweight object that represents a datetime.

  The Tiny Mandate
      Many CPAN modules which provide the best implementation of a certain
      concepts are very large. For some reason, this generally seems to be
      about 3 megabyte of ram usage to load the module.

      For a lot of the situations in which these large and comprehensive
      implementations exist, some people will only need a small fraction of
      the functionality, or only need this functionality in an ancillary
      role.

      The aim of the Tiny modules is to implement an alternative to the large
      module that implements a useful subset of their functionality, using as
      little code as possible.

      Typically, this means a module that implements between 50% and 80% of
      the features of the larger module (although this is just a guideline),
      but using only 100 kilobytes of code, which is about 1/30th of the
      larger module.

  The Concept of Tiny Date and Time
      Due to the inherent complexity, Date and Time is intrinsically very
      difficult to implement properly.

      The arguably *only* module to implement it completely correct is the
      DateTime manpage. However, to implement it properly the DateTime
      manpage is quite slow and requires 3-4 megabytes of memory to load.

      The challenge in implementing a Tiny equivalent to DateTime is to do so
      without making the functionality critically flawed, and to carefully
      select the subset of functionality to implement.

      If you look at where the main complexity and cost exists, you will find
      that it is relatively cheap to represent a date or time as an object,
      but much much more expensive to modify, manipulate or convert the
      object.

      As a result, *DateTime::Tiny* provides the functionality required to
      represent a date as an object, to stringify the date and to parse it
      back in, but does *not* allow you to modify the dates.

      The purpose of this is to allow for date object representations in
      situations like log parsing and fast real-time type work.

      The problem with this is that having no ability to modify date limits
      the usefulness greatly.

      To make up for this, *if* you have the DateTime manpage installed, any
      *DateTime::Tiny* module can be inflated into the equivalent the
      DateTime manpage as needing, loading the DateTime manpage on the fly if
      necesary.

      This is somewhat similar to DateTime::LazyInit, but unlike that module
      *DateTime::Tiny* is not modifiable.

      For the purposes of date/time logic, all *DateTime::Tiny* objects exist
      in the "C" locale, and the "floating" time zone. This may be improved
      in the future if a suitably tiny way of handling timezones is found.

      When converting up to full the DateTime manpage objects, these local
      and time zone settings will be applied (although an ability is provided
      to override this).

      In addition, the implementation is strictly correct and is intended to
      be very easily to sub-class for specific purposes of your own.


pkgId: 581ca43d787984e5b5a0cd5a2289d37b6df0ddf5038ce699767a65023d968aad
name: perl-Debug-Trace
arch: src
version: 0.04
epoch: 0
release: 9.1.1
summary: Perl extension to trace subroutine calls
url: http://search.cpan.org/dist/Debug-Trace/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Debug-Trace-0.04-9.1.1.src.rpm
checksum_type: sha256
description:
  Debug::Trace instruments subroutines to provide tracing information upon
  every call and return.

  Authors:
  --------
      Jan-Pieter Cornet <jpc@cpan.org>
      Jos Boumans <kane@cpan.org>
      Johan Vromans <jv@cpan.org>


pkgId: 491b9fcae3bed654db7755f27d3a49b3cc28bc644ea1a482fde880b2f279fbe6
name: perl-Declare-Constraints-Simple
arch: src
version: 0.03
epoch: 0
release: 10.1.1
summary: Declarative Validation of Data Structures
url: http://search.cpan.org/dist/Declare-Constraints-Simple/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Declare-Constraints-Simple-0.03-10.1.1.src.rpm
checksum_type: sha256
description:
  The main purpose of this module is to provide an easy way to build a
  profile to validate a data structure. It does this by giving you a set of
  declarative keywords in the importing namespace.


pkgId: 51fc2f9f57f92695d5cafd750fcc91caf491fd2230cc2810423d7acc82fe433e
name: perl-Devel-Caller
arch: src
version: 2.05
epoch: 0
release: 4.1.1
summary: meatier versions of C<caller>
url: http://search.cpan.org/dist/Devel-Caller/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-Caller-2.05-4.1.1.src.rpm
checksum_type: sha256
description:
  * caller_cv($level)

    'caller_cv' gives you the coderef of the subroutine being invoked at the
    call frame indicated by the value of $level

  * caller_args($level)

    Returns the arguments passed into the caller at level $level

  * caller_vars( $level, $names )
    =item called_with($level, $names)

    'called_with' returns a list of references to the original arguments to
    the subroutine at $level. if $names is true, the names of the variables
    will be returned instead

    constants are returned as 'undef' in both cases

  * called_as_method($level)

    'called_as_method' returns true if the subroutine at $level was called as
    a method.


pkgId: 4603affd0303f7fb872f9ecc082952ca5f654885b4795d4dc19ae1fab847e41c
name: perl-Devel-CoreStack
arch: src
version: 1.3
epoch: 0
release: 301.1.1
summary: try to generate a stack dump from a core file
url: http://cpan.org/modules/by-module/Devel/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Languages/Perl
rpm_buildhost: build34
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-CoreStack-1.3-301.1.1.src.rpm
checksum_type: sha256
description:
  This module attempts to generate a stack dump from a core file by
  locating the best available debugger (if any) and running it with the
  appropriate arguments and command script.



  Authors:
  --------
      Alligator Descartes <descarte@hermetica.com>
      Tim Bunce


pkgId: eba046e1f3ba26466b5cf6fcf65df28282689ef863548d2213488af3a65cd2fc
name: perl-Devel-Cover
arch: src
version: 0.87
epoch: 0
release: 4.1.1
summary: Code coverage metrics for Perl
url: http://search.cpan.org/dist/Devel-Cover/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-Cover-0.87-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides code coverage metrics for Perl. Code coverage metrics
  describe how thoroughly tests exercise code. By using Devel::Cover you can
  discover areas of code not exercised by your tests and determine which
  tests to create to increase coverage. Code coverage can be considered as an
  indirect measure of quality.

  Although it is still being developed, Devel::Cover is now quite stable and
  provides many of the features to be expected in a useful coverage tool.

  Statement, branch, condition, subroutine, and pod coverage information is
  reported. Statement coverage data should be reasonable. Branch and
  condition coverage data should be mostly accurate too, although not always
  what one might initially expect. Subroutine coverage should be as accurate
  as statement coverage. Pod coverage comes from the Pod::Coverage manpage.
  If the Pod::Coverage::CountParents manpage is available it will be used
  instead. Coverage data for other criteria are not yet collected.

  The _cover_ program can be used to generate coverage reports. Devel::Cover
  ships with a number of different reports including various types of HTML
  output, textual reports, a report to display missing coverage in the same
  format as compilation errors and a report to display coverage information
  within the Vim editor.

  It is possible to add annotations to reports, for example you could add a
  column to an HTML report showing who last changed a line, as determined by
  git blame. Some annotation modules are shipped with Devel::Cover and you
  can easily create your own.

  The _gcov2perl_ program can be used to convert gcov files to 'Devel::Cover'
  databases. This allows you to display your C or XS code coverage together
  with your Perl coverage, or to use any of the Devel::Cvoer reports to
  display your C coverage data.

  You may find that the coverage results don't match your expectations. This
  could be due to a bug in Devel::Cover, but code coverage can be unintuitive
  to newcomers, and especially so with Perl, so you may want to reconsider
  your expectations as well.

  Code coverage data are collected by replacing perl ops with functions which
  count how many times the ops are executed. These data are then mapped back
  to reality using the B compiler modules. There is also a statement
  profiling facility which should not be relied on. For proper profiling use
  Devel::NYTProf. Previous versions of Devel::Cover collected coverage data
  by replacing perl's runops function. It is still possible to switch to that
  mode of operation, but this now gets little testing and will probably be
  removed soon. You probably don't care about any of this.

  The most appropriate mailing list on which to discuss this module would be
  perl-qa. Discussion has migrated there from perl-qa-metrics which is now
  defunct. See the http://lists.perl.org/list/perl-qa.html manpage.

  The Devel::Cover repository can be found at the
  http://github.com/pjcj/Devel--Cover manpage.


pkgId: 930b344d25a2962aa3083233ccc9985dde73b487dd4cc849bae79ff1316ff4c8
name: perl-Devel-Cycle
arch: src
version: 1.11
epoch: 0
release: 14.1.1
summary: Find memory cycles in objects
url: http://search.cpan.org/dist/Devel-Cycle/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-Cycle-1.11-14.1.1.src.rpm
checksum_type: sha256
description:
  This is a simple developer's tool for finding circular references in
  objects and other types of references. Because of Perl's reference-count
  based memory management, circular references will cause memory leaks.

  Authors:
  --------
      Lincoln Stein, <lstein@cshl.edu>


pkgId: b8cde4828e613e5097b7d345a6a484e576dcefc9875ca42a34086a94c4c9dd3e
name: perl-Devel-Declare
arch: src
version: 0.006008
epoch: 0
release: 4.1.1
summary: Adding keywords to perl, in perl
url: http://search.cpan.org/dist/Devel-Declare/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-Declare-0.006008-4.1.1.src.rpm
checksum_type: sha256
description:
  the Devel::Declare manpage can install subroutines called declarators which
  locally take over Perl's parser, allowing the creation of new syntax.

  This document describes how to create a simple declarator.


pkgId: 40c696a39a54a2f524d071d072aa7f294128e10ca63e3c1f0c01abbd9ac42572
name: perl-Devel-GlobalDestruction
arch: src
version: 0.04
epoch: 0
release: 5.1.1
summary: Expose PL_dirty, the flag which marks global
url: http://search.cpan.org/dist/Devel-GlobalDestruction/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-GlobalDestruction-0.04-5.1.1.src.rpm
checksum_type: sha256
description:
  Perl's global destruction is a little tricky to deal with WRT finalizers
  because it's not ordered and objects can sometimes disappear.

  Writing defensive destructors is hard and annoying, and usually if global
  destruction is happenning you only need the destructors that free up non
  process local resources to actually execute.

  For these constructors you can avoid the mess by simply bailing out if
  global destruction is in effect.


pkgId: 3e34676129c25b8e876422ada74ee536ac43063fc698085ee890746ac8cb156f
name: perl-Devel-Leak
arch: src
version: 0.03
epoch: 0
release: 20.1.1
summary: Utility for looking for perl objects that are not reclaimed
url: http://search.cpan.org/~ni-s/Devel-Leak-0.03
rpm_license: GPL-1.0 or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-Leak-0.03-20.1.1.src.rpm
checksum_type: sha256
description:
   Devel-Leak module for perl
    Devel::Leak has two functions NoteSV and CheckSV.
    NoteSV walks the perl internal table of allocated SVs (scalar values)
     - (which actually contains arrays and hashes too),
     and records their addresses in a table. It returns a count of these "things",
     and stores a pointer to the table (which is obtained from the heap
     using malloc()) in its argument.
    CheckSV is passed argument which holds a pointer to a table created by NoteSV.
     It re-walks the perl-internals and calls sv_dump() for any "things"
     which did not exist when NoteSV was called.
     It returns a count of the number of "things" now allocated.
    Author:	Nick Ing-Simmons <nick@ni-s.u-net.com>


pkgId: f53969fa2d36074f16aff946e68fc9bf69b80e6a0e7532b461aa5d3da7d6a3cf
name: perl-Devel-LexAlias
arch: src
version: 0.04
epoch: 0
release: 5.1.1
summary: Alias Lexical Variables
url: http://search.cpan.org/dist/Devel-LexAlias/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-LexAlias-0.04-5.1.1.src.rpm
checksum_type: sha256
description:
  Devel::LexAlias provides the ability to alias a lexical variable in a
  subroutines scope to one of your choosing.


pkgId: 6fae841badaf7cb77aec1113092fbcfd14eb67672d72e8c0093e56dad37f6d52
name: perl-Devel-NYTProf
arch: src
version: 4.06
epoch: 0
release: 4.1.1
summary: Powerful fast feature-rich perl source code profiler
url: http://search.cpan.org/dist/Devel-NYTProf/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-NYTProf-4.06-4.1.1.src.rpm
checksum_type: sha256
description:
  Devel::NYTProf is a powerful, fast, feature-rich perl source code profiler.

  * Performs per-line statement profiling for fine detail
  * Performs per-subroutine statement profiling for overview
  * Performs per-opcode profiling for slow perl builtins
  * Performs per-block statement profiling (the first profiler to do so)
  * Accounts correctly for time spent after calls return
  * Performs inclusive and exclusive timing of subroutines
  * Subroutine times are per calling location (a powerful feature)
  * Can profile compile-time activity, just run-time, or just END time
  * Uses novel techniques for efficient profiling
  * Sub-microsecond (100ns) resolution on supported systems
  * Very fast - the fastest statement and subroutine profilers for perl
  * Handles applications that fork, with no performance cost
  * Immune from noise caused by profiling overheads and I/O
  * Program being profiled can stop/start the profiler
  * Generates richly annotated and cross-linked html reports
  * Captures source code, including string evals, for stable results
  * Trivial to use with mod_perl - add one line to httpd.conf
  * Includes an extensive test suite
  * Tested on very large codebases

  NYTProf is effectively two profilers in one: a statement profiler, and a
  subroutine profiler.


pkgId: 9fbae3b8c4065f6601caf6cc6c4878c547a49111af1d8ee0f7560082ecf4dba9
name: perl-Devel-PatchPerl
arch: src
version: 0.66
epoch: 0
release: 4.1.1
summary: Patch perl source a la Devel::PPPort's buildperl.pl
url: http://search.cpan.org/dist/Devel-PatchPerl/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-PatchPerl-0.66-4.1.1.src.rpm
checksum_type: sha256
description:
  Devel::PatchPerl is a modularisation of the patching code contained in the
  Devel::PPPort manpage's 'buildperl.pl'.

  It does not build perls, it merely provides an interface to the source
  patching functionality.


pkgId: 26d312d0f26b2ba2a45521159cacb5d165f528c4d58b7d1e36979858c9a53515
name: perl-Devel-REPL
arch: src
version: 1.003014
epoch: 0
release: 2.1.1
summary: Modern perl interactive shell
url: http://search.cpan.org/dist/Devel-REPL/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-REPL-1.003014-2.1.1.src.rpm
checksum_type: sha256
description:
  This is an interactive shell for Perl, commonly known as a REPL - Read,
  Evaluate, Print, Loop. The shell provides for rapid development or testing
  of code without the need to create a temporary source code file.

  Through a plugin system, many features are available on demand. You can
  also tailor the environment through the use of profiles and run control
  files, for example to pre-load certain Perl modules when working on a
  particular project.


pkgId: 27010a933caf9a8ed19209f073289d74ae56c314340c6fd83512ff0818a9ecae
name: perl-Devel-StackTrace
arch: src
version: 1.27
epoch: 0
release: 12.1.1
summary: An object representing a stack trace
url: http://search.cpan.org/dist/Devel-StackTrace/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-StackTrace-1.27-12.1.1.src.rpm
checksum_type: sha256
description:
  The Devel::StackTrace module contains two classes, Devel::StackTrace and
  Devel::StackTrace::Frame. The goal of this object is to encapsulate the
  information that can found through using the 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 the Exception::Class::Base manpage
  class (part of Exception::Class) but may be useful in other contexts.


pkgId: 33b51be91a92fce114dceea686f2628cc34fa8ffe9610473e3e3fa4e6abda4ec
name: perl-Devel-StackTrace-AsHTML
arch: src
version: 0.11
epoch: 0
release: 8.1.1
summary: Displays stack trace in HTML
url: http://search.cpan.org/dist/Devel-StackTrace-AsHTML/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-StackTrace-AsHTML-0.11-8.1.1.src.rpm
checksum_type: sha256
description:
  Devel::StackTrace::AsHTML adds 'as_html' method to the Devel::StackTrace
  manpage which displays the stack trace in beautiful HTML, with code snippet
  context and function parameters. If you call it on an instance of the
  Devel::StackTrace::WithLexicals manpage, you even get to see the lexical
  variables of each stack frame.


pkgId: 1b4226fc4e7dc96f4ae482b097ae92753363d10bfa8c3861e67876c34efd8780
name: perl-Devel-Symdump
arch: src
version: 2.08
epoch: 0
release: 23.1.1
summary: Dump symbol names or the symbol table
url: http://cpan.org/modules/by-module/Devel/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Devel-Symdump-2.08-23.1.1.src.rpm
checksum_type: sha256
description:
   Devel-Symdump module for perl
  This little package serves to access the symbol table of perl.
    Author:       Andreas Koenig <andk@cpan.org>
                  Tom Christiansen <tchrist@perl.com>
          Based on the old dumpvar.pl by Larry Wall.


pkgId: e4b2f9bedb5a539988f8d39ef086ca208e0a81caad8ae6446d92b46cdb6bfa64
name: perl-Device-SerialPort
arch: src
version: 1.04
epoch: 0
release: 21.1.1
summary: Linux/POSIX emulation of Win32::SerialPort functions
url: http://search.cpan.org/dist/Device-SerialPort/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Device-SerialPort-1.04-21.1.1.src.rpm
checksum_type: sha256
description:
  This module provides an object-based user interface essentially identical
  to the one provided by the Win32::SerialPort module.


pkgId: 64f02de7b4ac314a1ebaeee01c3e531bb44ef1d3a8264f1bbd4fc1a661683272
name: perl-Digest-CRC
arch: src
version: 0.18
epoch: 0
release: 4.1.1
summary: Generic CRC functions for Perl
url: http://search.cpan.org/dist/Digest-CRC/
rpm_license: SUSE-Public-Domain
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-CRC-0.18-4.1.1.src.rpm
checksum_type: sha256
description:
  The Digest::CRC module calculates CRC sums of all sorts.  It contains
  wrapper functions with the correct parameters for CRC-CCITT, CRC-16,
  CRC-32 and CRC-64.


pkgId: 5b286c57006cc195f2193fd5454b537d91689e3b2d518841a24f7179fc604a40
name: perl-Digest-HMAC
arch: src
version: 1.03
epoch: 0
release: 14.1.1
summary: Keyed-Hashing for Message Authentication
url: http://search.cpan.org/dist/Digest-HMAC/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-HMAC-1.03-14.1.1.src.rpm
checksum_type: sha256
description:
  HMAC is used for message integrity checks between two parties that share a
  secret key, and works in combination with some other Digest algorithm,
  usually MD5 or SHA-1. The HMAC mechanism is described in RFC 2104.

  HMAC follow the common 'Digest::' interface, but the constructor takes the
  secret key and the name of some other simple 'Digest::' as argument.

  Authors:
  --------
      Graham Barr <gbarr@ti.com>
      Gisle Aas <gisle@aas.no>


pkgId: c4c1a54b581699ff9cca8c4f310c9a68fe3244068b0dea65bea995f10e42cc2e
name: perl-Digest-JHash
arch: src
version: 0.07
epoch: 0
release: 8.1.1
summary: Perl extension for 32 bit Jenkins Hashing Algorithm
url: http://search.cpan.org/dist/Digest-JHash/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-JHash-0.07-8.1.1.src.rpm
checksum_type: sha256
description:
  The 'Digest::JHash' module allows you to use the fast JHash hashing
  algorithm developed by Bob Jenkins from within Perl programs. The algorithm
  takes as input a message of arbitrary length and produces as output a
  32-bit "message digest" of the input in the form of an unsigned long
  integer.

  Call it a low calorie version of MD5 if you like.

  See http://burtleburtle.net/bob/hash/doobs.html for more information.


pkgId: 883f946db657c1c5d1f24cfdf0d813ee7be7288f2a2224bee4888ee84c13e898
name: perl-Digest-MD4
arch: src
version: 1.5
epoch: 0
release: 156.1.1
summary: Perl interface to the MD4 Algorithm
url: http://search.cpan.org/dist/Digest-MD4/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-MD4-1.5-156.1.1.src.rpm
checksum_type: sha256
description:
  The 'Digest::MD4' module allows you to use the RSA Data Security Inc. MD4
  Message Digest algorithm from within Perl programs. The algorithm takes as
  input a message of arbitrary length and produces as output a 128-bit
  "fingerprint" or "message digest" of the input.

  The 'Digest::MD4' module provides a procedural interface for simple use, as
  well as an object oriented interface that can handle messages of arbitrary
  length and which can read files directly.


pkgId: 4601d142a09f37fd641a13b509ff5f9f8c9f062d292865b0991f36db1db7c204
name: perl-Digest-Perl-MD5
arch: src
version: 1.8
epoch: 0
release: 8.1.1
summary: Perl implementation of Ron Rivests MD5 Algorithm
url: http://search.cpan.org/dist/Digest-Perl-MD5/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-Perl-MD5-1.8-8.1.1.src.rpm
checksum_type: sha256
description:
  This modules has the same interface as the much faster 'Digest::MD5'. So
  you can easily exchange them, e.g.

  	BEGIN {
  	  eval {
  	    require Digest::MD5;
  	    import Digest::MD5 'md5_hex'
  	  };
  	  if ($@) { # ups, no Digest::MD5
  	    require Digest::Perl::MD5;
  	    import Digest::Perl::MD5 'md5_hex'
  	  }
  	}

  If the 'Digest::MD5' module is available it is used and if not you take
  'Digest::Perl::MD5'.

  You can also install the Perl part of Digest::MD5 together with
  Digest::Perl::MD5 and use Digest::MD5 as normal, it falls back to
  Digest::Perl::MD5 if it cannot load its object files.

  For a detailed Documentation see the 'Digest::MD5' module.


pkgId: 582ea5af9242b60e2c77080b2243b2313775bf12d87c0b36774410ca0f8d6dfa
name: perl-Digest-SHA1
arch: src
version: 2.13
epoch: 0
release: 13.1.1
summary: Perl Interface to the SHA-1 Algorithm
url: http://search.cpan.org/perldoc?Digest::SHA1
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-SHA1-2.13-13.1.1.src.rpm
checksum_type: sha256
description:
   Digest-SHA1 module for perl
    The Digest::SHA1 module allows the use of the NIST SHA-1 message digest
    algorithm from within Perl programs. The algorithm takes a message of
    arbitrary length as input and produces a 160-bit fingerprint or message
    digest of the input as output.
    Authors:
  		Peter C. Gutmann,
  		Uwe Hollerbach <uh@alumni.caltech.edu>,
  		Gisle Aas <gisle@aas.no>


pkgId: 92e9d23e7fdcf8d1827fe5f7267da28bfb465dd190c06bf22c4a3cea96320b8f
name: perl-Digest-Whirlpool
arch: src
version: 1.09
epoch: 0
release: 9.1.1
summary: A 512-bit, collision-resistant, one-way hash function
url: http://search.cpan.org/dist/Digest-Whirlpool/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Digest-Whirlpool-1.09-9.1.1.src.rpm
checksum_type: sha256
description:
  Provides an interface to the WHIRLPOOL hash algorithm. This module
  subclasses the Digest::base manpage and can be used either directly or
  through the the Digest manpage meta-module. Using the latter is
  recommended.


pkgId: 7f648d0ddf8ad5a84fb9f7ccc8f7df9eef19eca2e89ef5a6c8f32208b302dc21
name: perl-Dist-CheckConflicts
arch: src
version: 0.02
epoch: 0
release: 10.1.1
summary: Declare version conflicts for your dist
url: http://search.cpan.org/dist/Dist-CheckConflicts/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Dist-CheckConflicts-0.02-10.1.1.src.rpm
checksum_type: sha256
description:
  One shortcoming of the CPAN clients that currently exist is that they have
  no way of specifying conflicting downstream dependencies of modules. This
  module attempts to work around this issue by allowing you to specify
  conflicting versions of modules separately, and deal with them after the
  module is done installing.

  For instance, say you have a module 'Foo', and some other module 'Bar' uses
  'Foo'. If 'Foo' were to change its API in a non-backwards-compatible way,
  this would cause 'Bar' to break until it is updated to use the new API.
  'Foo' can't just depend on the fixed version of 'Bar', because this will
  cause a circular dependency (because 'Bar' is already depending on 'Foo'),
  and this doesn't express intent properly anyway - 'Foo' doesn't use 'Bar'
  at all. The ideal solution would be for there to be a way to specify
  conflicting versions of modules in a way that would let CPAN clients update
  conflicting modules automatically after an existing module is upgraded, but
  until that happens, this module will allow users to do this manually.

  This module accepts a hash of options passed to its 'use' statement, with
  these keys being valid:

  * -conflicts

    A hashref of conflict specifications, where keys are module names, and
    values are the last broken version - any version greater than the
    specified version should work.

  * -also

    Additional modules to get conflicts from (potentially recursively). This
    should generally be a list of modules which use Dist::CheckConflicts,
    which correspond to the dists that your dist depends on. (In an ideal
    world, this would be intuited directly from your dependency list, but the
    dependency list isn't available outside of build time).

  * -dist

    The name of the distribution, to make the error message from
    check_conflicts more user-friendly.

  The methods listed below are exported by this module into the module that
  uses it, so you should call these methods on your module, not
  Dist::CheckConflicts.

  As an example, this command line can be used to update your modules, after
  installing the 'Foo' dist (assuming that 'Foo::Conflicts' is the module in
  the 'Foo' dist which uses Dist::CheckConflicts):

      perl -MFoo::Conflicts -e'print "$_\n"
          for map { $_->{package} } Foo::Conflicts->calculate_conflicts' | cpanm


pkgId: b1eb3044a77384a4fe5a9c7d5c091a620e213a20fe423ad5d9c6e971e834adad
name: perl-Dist-Zilla
arch: src
version: 4.300009
epoch: 0
release: 4.1.1
summary: distribution builder; installer not included!
url: http://search.cpan.org/dist/Dist-Zilla/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Dist-Zilla-4.300009-4.1.1.src.rpm
checksum_type: sha256
description:
  Dist::Zilla builds distributions of code to be uploaded to the CPAN. In
  this respect, it is like the ExtUtils::MakeMaker manpage, the Module::Build
  manpage, or the Module::Install manpage. Unlike those tools, however, it is
  not also a system for installing code that has been downloaded from the
  CPAN. Since it's only run by authors, and is meant to be run on a
  repository checkout rather than on published, released code, it can do much
  more than those tools, and is free to make much more ludicrous demands in
  terms of prerequisites.

  If you have access to the web, you can learn more and find an interactive
  tutorial at *http://dzil.org/*. If not, try the Dist::Zilla::Tutorial
  manpage.


pkgId: fae5b69a2c974aa867668f19d4d13733bd2821413ef3c3c675c6be91ce2080b8
name: perl-Email-Address
arch: src
version: 1.892
epoch: 0
release: 11.1.1
summary: RFC 2822 Address Parsing and Creation
url: http://search.cpan.org/dist/Email-Address/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Email-Address-1.892-11.1.1.src.rpm
checksum_type: sha256
description:
  This class implements a regex-based RFC 2822 parser that locates email
  addresses in strings and returns a list of 'Email::Address' objects found.
  Alternatley you may construct objects manually. The goal of this software
  is to be correct, and very very fast.

  Authors:
  --------
       Originally by Casey West, <_casey@geeknest.com_>.
       Maintained, 2006-2007, Ricardo SIGNES <_rjbs@cpan.org_>.


pkgId: d3af57782c3cca4c3f330a91d4dec7fbd178b2b10a48cf820bc06a5476c71a88
name: perl-Email-Date-Format
arch: src
version: 1.002
epoch: 0
release: 25.1.1
summary: Produce RFC 2822 date strings
url: http://search.cpan.org/dist/Email-Date-Format/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Email-Date-Format-1.002-25.1.1.src.rpm
checksum_type: sha256
description:
  This module provides a simple means for generating an RFC 2822 compliant
  datetime string. (In case you care, they're not RFC 822 dates, because they
  use a four digit year, which is not allowed in RFC 822.)

  Authors:
  --------
       Ricardo SIGNES, <_rjbs@cpan.org_>.
       Adapted from Email::Date, by Casey West.


pkgId: ef3640c0cfe5038cab2b381eac1467a10905c91b5c004bdc51c243256d9e644d
name: perl-Email-MessageID
arch: src
version: 1.402
epoch: 0
release: 9.1.1
summary: Generate world unique message-ids.
url: http://search.cpan.org/dist/Email-MessageID/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Email-MessageID-1.402-9.1.1.src.rpm
checksum_type: sha256
description:
  Message-ids are optional, but highly recommended, headers that identify a
  message uniquely. This software generates a unique message-id.


pkgId: d3dc1fac3368486768bbc059cc139f983683f51f617a6694ffdf9f084df1c050
name: perl-Email-Simple
arch: src
version: 2.101
epoch: 0
release: 4.1.1
summary: Simple parsing of RFC2822 message format and headers
url: http://search.cpan.org/dist/Email-Simple/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Email-Simple-2.101-4.1.1.src.rpm
checksum_type: sha256
description:
  'Email::Simple' is the first deliverable of the "Perl Email Project." The
  Email:: namespace was begun as a reaction against the increasing complexity
  and bugginess of Perl's existing email modules. 'Email::*' modules are
  meant to be simple to use and to maintain, pared to the bone, fast, minimal
  in their external dependencies, and correct.


pkgId: 16d1178314cb1187bc8df36523ff5b7153e7a8dd582f63d631091e6e953d4664
name: perl-Email-Valid
arch: src
version: 0.187
epoch: 0
release: 4.1.1
summary: Check validity of Internet email addresses
url: http://search.cpan.org/dist/Email-Valid/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Email-Valid-0.187-4.1.1.src.rpm
checksum_type: sha256
description:
  This module determines whether an email address is well-formed, and
  optionally, whether a mail host exists for the domain.

  Please note that there is no way to determine whether an address is
  deliverable without attempting delivery (for details, see perlfaq 9).


pkgId: 923de2f0730e79a23d5c8f14a5e361309ce0f996b3e4583f760714425c86ad20
name: perl-Encode-Detect
arch: src
version: 1.01
epoch: 0
release: 15.1.2
summary: An Encode::Encoding subclass that detects the encoding of data
url: http://search.cpan.org/dist/Encode-Detect
rpm_license: MPL-1.1
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Encode-Detect-1.01-15.1.2.src.rpm
checksum_type: sha256
description:
  This Perl module is an Encode::Encoding subclass that uses
  Encode::Detect::Detector to determine the charset of the input data and then
  decodes it using the encoder of the detected charset.

  It is similar to Encode::Guess, but does not require the configuration of a set
  of expected encodings. Like Encode::Guess, it only supports decoding--it cannot
  encode.

  Authors:
  --------
      John Gardiner Myers <jgmyers@proofpoint.com>


pkgId: fddeaac61cec5da941243387339dd978cf8dbc981ea6d97798a74e4eed5e1cf3
name: perl-Encode-HanExtra
arch: src
version: 0.23
epoch: 0
release: 81.1.1
summary: Extra sets of Chinese encodings
url: http://search.cpan.org/~autrijus/Encode-HanExtra-0.23/
rpm_license: MIT
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Encode-HanExtra-0.23-81.1.1.src.rpm
checksum_type: sha256
description:
  Perl 5.7.3 and later ships with an adequate set of Chinese encodings,
  including the most used CP950, CP936 (also known as GBK), Big5,
  Big5-HKSCS, EUC-CN, HZ, and ISO-IR-165.

  However, the numbers of Chinese encodings are staggering, and a
  complete coverage will easily increase the size of perl distribution by
  several megabytes; hence, this CPAN module tries to provide the rest of
  them.



  Authors:
  --------
      Autrijus Tang <autrijus@autrijus.org>


pkgId: b06d98bedd72080b6229ddf5090062739fb0f36790eab6a63452304a84f13b1a
name: perl-Encode-JIS2K
arch: src
version: 0.02
epoch: 0
release: 157.1.1
summary: JIS X 0212 (aka JIS 2000) Encodings
url: http://search.cpan.org/~dankogai/Encode-JIS2K-0.02/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Encode-JIS2K-0.02-157.1.1.src.rpm
checksum_type: sha256
description:
  This module implements encodings that covers JIS X 0213 charset (AKA
  JIS 2000, hence the module name).



  Authors:
  --------
      Dan Kogai <dankogai@dan.co.jp>


pkgId: e64addf79314a06cf7958b627c3a33ce1f3d0f8cb574e46f38b55cca200c5681
name: perl-Encode-Locale
arch: src
version: 1.03
epoch: 0
release: 4.1.1
summary: Determine the locale encoding
url: http://search.cpan.org/dist/Encode-Locale/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Encode-Locale-1.03-4.1.1.src.rpm
checksum_type: sha256
description:
  In many applications it's wise to let Perl use Unicode for the strings it
  processes. Most of the interfaces Perl has to the outside world are still
  byte based. Programs therefore need to decode byte strings that enter the
  program from the outside and encode them again on the way out.

  The POSIX locale system is used to specify both the language conventions
  requested by the user and the preferred character set to consume and
  output. The 'Encode::Locale' module looks up the charset and encoding
  (called a CODESET in the locale jargon) and arranges for the the Encode
  manpage module to know this encoding under the name "locale". It means
  bytes obtained from the environment can be converted to Unicode strings by
  calling 'Encode::encode(locale => $bytes)' and converted back again with
  'Encode::decode(locale => $string)'.

  Where file systems interfaces pass file names in and out of the program we
  also need care. The trend is for operating systems to use a fixed file
  encoding that don't actually depend on the locale; and this module
  determines the most appropriate encoding for file names. The the Encode
  manpage module will know this encoding under the name "locale_fs". For
  traditional Unix systems this will be an alias to the same encoding as
  "locale".

  For programs running in a terminal window (called a "Console" on some
  systems) the "locale" encoding is usually a good choice for what to expect
  as input and output. Some systems allows us to query the encoding set for
  the terminal and 'Encode::Locale' will do that if available and make these
  encodings known under the 'Encode' aliases "console_in" and "console_out".
  For systems where we can't determine the terminal encoding these will be
  aliased as the same encoding as "locale". The advice is to use "console_in"
  for input known to come from the terminal and "console_out" for output
  known to go from the terminal.

  In addition to arranging for various Encode aliases the following functions
  and variables are provided:

  * decode_argv( )

  * decode_argv( Encode::FB_CROAK )

    This will decode the command line arguments to perl (the '@ARGV' array)
    in-place.

    The function will by default replace characters that can't be decoded by
    "\x{FFFD}", the Unicode replacement character.

    Any argument provided is passed as CHECK to underlying Encode::decode()
    call. Pass the value 'Encode::FB_CROAK' to have the decoding croak if not
    all the command line arguments can be decoded. See the Encode/"Handling
    Malformed Data" manpage for details on other options for CHECK.

  * env( $uni_key )

  * env( $uni_key => $uni_value )

    Interface to get/set environment variables. Returns the current value as
    a Unicode string. The $uni_key and $uni_value arguments are expected to
    be Unicode strings as well. Passing 'undef' as $uni_value deletes the
    environment variable named $uni_key.

    The returned value will have the characters that can't be decoded
    replaced by "\x{FFFD}", the Unicode replacement character.

    There is no interface to request alternative CHECK behavior as for
    decode_argv(). If you need that you need to call encode/decode yourself.
    For example:

        my $key = Encode::encode(locale => $uni_key, Encode::FB_CROAK);
        my $uni_value = Encode::decode(locale => $ENV{$key}, Encode::FB_CROAK);

  * reinit( )

  * reinit( $encoding )

    Reinitialize the encodings from the locale. You want to call this
    function if you changed anything in the environment that might influence
    the locale.

    This function will croak if the determined encoding isn't recognized by
    the Encode module.

    With argument force $ENCODING_... variables to set to the given value.

  * $ENCODING_LOCALE

    The encoding name determined to be suitable for the current locale. the
    Encode manpage know this encoding as "locale".

  * $ENCODING_LOCALE_FS

    The encoding name determined to be suiteable for file system interfaces
    involving file names. the Encode manpage know this encoding as
    "locale_fs".

  * $ENCODING_CONSOLE_IN

  * $ENCODING_CONSOLE_OUT

    The encodings to be used for reading and writing output to the a console.
    the Encode manpage know these encodings as "console_in" and
    "console_out".


pkgId: c4ca796e5207711fd88133ece8348d06c9a5c7e2db9948e160b7e561da686956
name: perl-Error
arch: src
version: 0.17017
epoch: 0
release: 10.1.1
summary: Error/exception handling in an OO-ish way
url: http://search.cpan.org/dist/Error/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Error-0.17017-10.1.1.src.rpm
checksum_type: sha256
description:
  The 'Error' package provides two interfaces. Firstly 'Error' provides a
  procedural interface to exception handling. Secondly 'Error' is a base
  class for errors/exceptions that can either be thrown, for subsequent
  catch, or can simply be recorded.

  Errors in the class 'Error' should not be thrown directly, but the user
  should throw errors from a sub-class of 'Error'.


pkgId: 80e82362270dbfab51784940fe6e20262700979b337da29ccd73ea82ca36bfc9
name: perl-Eval-Closure
arch: src
version: 0.08
epoch: 0
release: 4.1.1
summary: Safely and cleanly create closures via string eval
url: http://search.cpan.org/dist/Eval-Closure/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Eval-Closure-0.08-4.1.1.src.rpm
checksum_type: sha256
description:
  String eval is often used for dynamic code generation. For instance,
  'Moose' uses it heavily, to generate inlined versions of accessors and
  constructors, which speeds code up at runtime by a significant amount.
  String eval is not without its issues however - it's difficult to control
  the scope it's used in (which determines which variables are in scope
  inside the eval), and it can be quite slow, especially if doing a large
  number of evals.

  This module attempts to solve both of those problems. It provides an
  'eval_closure' function, which evals a string in a clean environment, other
  than a fixed list of specified variables. It also caches the result of the
  eval, so that doing repeated evals of the same source, even with a
  different environment, will be much faster (but note that the description
  is part of the string to be evaled, so it must also be the same (or
  non-existent) if caching is to work properly).


pkgId: 226908ba2065701ebc9a47096929ec6d7bfe48ad2d9a1e1a44f85a560dbf28f1
name: perl-Event
arch: src
version: 1.20
epoch: 0
release: 7.1.1
summary: Event loop processing
url: http://search.cpan.org/dist/Event/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Event-1.20-7.1.1.src.rpm
checksum_type: sha256
description:
  ALERT: Marc Lehmann may have taken over the future of event loops in Perl.
  Check out his libev library and EV Perl module. 25 Aug 2009

  The Event module provide a central facility to watch for various types of
  events and invoke a callback when these events occur. The idea is to delay
  the handling of events so that they may be dispatched in priority order
  when it is safe for callbacks to execute.

  Events (in the ordinary sense of the word) are detected by *watchers*,
  which reify them as *events* (in the special Event module sense). For
  clarity, the former type of events may be called "source events", and the
  latter "target events". Source events, such as signals arriving, happen
  whether or not they are being watched. If a source event occurs which a
  watcher is actively watching then the watcher generates a corresponding
  target event. Target events are only created by watchers. If several
  watchers are interested in the same source event then each will generate
  their own target event. Hence, any particular source event may result in
  zero, one, two, or any number of target events: the same as the number of
  watchers which were actively watching for it.

  Target events are queued to be processed in priority order (priority being
  determined by the creating watcher) and in FIFO order among events of the
  same priority. Queued ("pending") events can, in some cases, be cancelled
  before being processed. A queued event is processed by being passed to the
  callback function (or method on a particular object or class) which was
  specified to the watcher.

  A watcher, once created, operates autonomously without the Event user
  having to retain any reference to it. However, keeping a reference makes it
  possible to modify most of the watcher's characteristics. A watcher can be
  switched between active and inactive states. When inactive, it does not
  generate target events.

  Some types of source event are not reified as target events immediately.
  Signals received, for example, are counted initially. The counted signals
  are reified at certain execution points. Hence, signal events may be
  processed out of order, and if handled carelessly, on the wrong side of a
  state change in event handling. A useful way to view this is that
  occurrence of the source event is not actually the arrival of the signal
  but is triggered by the counting of the signal.

  Reification can be forced when necessary. The schedule on which some other
  events are created is non-obvious. This is especially the case with
  watchers that watch for a condition rather than an event. In some cases,
  target events are generated on a schedule that depends on the operation of
  the event loop.


pkgId: 962a8fe697ba6c6ef3151fde00c77cddec5b3aa9427292313c4c0cecbe2c7355
name: perl-Exception-Base
arch: src
version: 0.2401
epoch: 0
release: 4.1.1
summary: Lightweight exceptions
url: http://search.cpan.org/dist/Exception-Base/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Exception-Base-0.2401-4.1.1.src.rpm
checksum_type: sha256
description:
  This class implements a fully OO exception mechanism similar to the
  Exception::Class manpage or the Class::Throwable manpage. It provides a
  simple interface allowing programmers to declare exception classes. These
  classes can be thrown and caught. Each uncaught exception prints full stack
  trace if the default verbosity is uppered for debugging purposes.

  The features of 'Exception::Base':

  * *

    fast implementation of the exception class

  * *

    fully OO without closures and source code filtering

  * *

    does not mess with '$SIG{__DIE__}' and '$SIG{__WARN__}'

  * *

    no external run-time modules dependencies, requires core Perl modules
    only

  * *

    the default behavior of exception class can be changed globally or just
    for the thrown exception

  * *

    matching the exception by class, message or other attributes

  * *

    matching with string, regex or closure function

  * *

    creating automatically the derived exception classes (the perlfunc/use
    manpage interface)

  * *

    easly expendable, see the Exception::System manpage class for example

  * *

    prints just an error message or dumps full stack trace

  * *

    can propagate (rethrow) an exception

  * *

    can ignore some packages for stack trace output

  * *

    some defaults (i.e. verbosity) can be different for different exceptions


pkgId: eefa959d5d53748b6d6edf7af6137736f58086d36fc13fde3c575107b22e8595
name: perl-Exception-Class
arch: src
version: 1.32
epoch: 0
release: 5.1.1
summary: A Module That Allows You to Declare Real Exception Classes in Perl
url: http://search.cpan.org/dist/Exception-Class
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Exception-Class-1.32-5.1.1.src.rpm
checksum_type: sha256
description:
  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.

    Author:	Dave Rolsky <autarch@urth.org>


pkgId: 3d1c043cfc79a87704e3ae9447d4794a3f9db6e26e99e26890204849635f93ec
name: perl-Expect
arch: src
version: 1.21
epoch: 0
release: 65.1.1
summary: Expect for perl
url: http://search.cpan.org/search?module=Expect
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Expect-1.21-65.1.1.src.rpm
checksum_type: sha256
description:
  A tool for automating interactive programs



  Authors:
  --------
      Roland Giersig <RGiersig@cpan.org>
      Austin Schutz <tex@habit.com>


pkgId: c243187f2521ce6a11cc20e818efa3ada1d8629bc3a06b50c73d195a5aab1ea6
name: perl-Exporter-Declare
arch: src
version: 0.105
epoch: 0
release: 4.1.1
summary: Exporting done right
url: http://search.cpan.org/dist/Exporter-Declare/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Exporter-Declare-0.105-4.1.1.src.rpm
checksum_type: sha256
description:
  Exporter::Declare is a meta-driven exporting tool. Exporter::Declare tries
  to adopt all the good features of other exporting tools, while throwing
  away horrible interfaces. Exporter::Declare also provides hooks that allow
  you to add options and arguments for import. Finally, Exporter::Declare's
  meta-driven system allows for top-notch introspection.


pkgId: 803fb47d852b91056af61189860f168fd92dbce2eff3998bde9579dce0e62a31
name: perl-Exporter-Lite
arch: src
version: 0.02
epoch: 0
release: 8.1.1
summary: Lightweight exporting of variables
url: http://search.cpan.org/dist/Exporter-Lite/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Exporter-Lite-0.02-8.1.1.src.rpm
checksum_type: sha256
description:
  This is an alternative to Exporter intended to provide a lightweight subset
  of its functionality. It supports 'import()', '@EXPORT' and '@EXPORT_OK'
  and not a whole lot else.

  Unlike Exporter, it is not necessary to inherit from Exporter::Lite (ie. no
  '@ISA = qw(Exporter::Lite)' mantra). Exporter::Lite simply exports its
  import() function. This might be called a "mix-in".

  Setting up a module to export its variables and functions is simple:

      package My::Module;
      use Exporter::Lite;

      @EXPORT = qw($Foo bar);

  now when you 'use My::Module', '$Foo' and 'bar()' will show up.

  In order to make exporting optional, use @EXPORT_OK.

      package My::Module;
      use Exporter::Lite;

      @EXPORT_OK = qw($Foo bar);

  when My::Module is used, '$Foo' and 'bar()' will _not_ show up. You have to
  ask for them. 'use My::Module qw($Foo bar)'.


pkgId: abf5ac19194d50c1c03ba8860c69b0a2f64bb047c6b5697985597f4ee755b517
name: perl-Exporter-Tidy
arch: src
version: 0.07
epoch: 0
release: 20.1.1
summary: Another way of exporting symbols
url: http://search.cpan.org/dist/Exporter-Tidy/
rpm_license: SUSE-Public-Domain
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Exporter-Tidy-0.07-20.1.1.src.rpm
checksum_type: sha256
description:
  This module serves as an easy, clean alternative to Exporter. Unlike
  Exporter, it is not subclassed, but it simply exports a custom import()
  into your namespace.


pkgId: 2c5fbb7dfe88c6b781f95ea7bb4fa8c047e69f451752ad5d9e1f75db00926f34
name: perl-ExtUtils-CBuilder
arch: src
version: 0.280205
epoch: 0
release: 4.1.1
summary: Compile and link C code for Perl modules
url: http://search.cpan.org/dist/ExtUtils-CBuilder/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-ExtUtils-CBuilder-0.280205-4.1.1.src.rpm
checksum_type: sha256
description:
  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!


pkgId: 2a54de1c773dad8e7fba2782492f742603739d46fdd666536788946f6e5fa131
name: perl-ExtUtils-CChecker
arch: src
version: 0.07
epoch: 0
release: 4.1.1
summary: Configure-time utilities for using C headers
url: http://search.cpan.org/dist/ExtUtils-CChecker/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-ExtUtils-CChecker-0.07-4.1.1.src.rpm
checksum_type: sha256
description:
  Often Perl modules are written to wrap functionallity found in existing C
  headers, libraries, or to use OS-specific features. It is useful in the
  _Build.PL_ or _Makefile.PL_ file to check for the existance of these
  requirements before attempting to actually build the module.

  Objects in this class provide an extension around the ExtUtils::CBuilder
  manpage to simplify the creation of a _.c_ file, compiling, linking and
  running it, to test if a certain feature is present.

  It may also be necessary to search for the correct library to link against,
  or for the right include directories to find header files in. This class
  also provides assistance here.


pkgId: 0d3aaf41107ae7123f392f222c0b17c6b552a80296af5cb19a5c5df55a8f5b44
name: perl-ExtUtils-Depends
arch: src
version: 0.304
epoch: 0
release: 11.1.1
summary: Easily build XS extensions that depend on XS extensions
url: http://search.cpan.org/dist/ExtUtils-Depends/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-ExtUtils-Depends-0.304-11.1.1.src.rpm
checksum_type: sha256
description:
  This module tries to make it easy to build Perl extensions that use
  functions and typemaps provided by other perl extensions. This means that a
  perl extension is treated like a shared library that provides also a C and
  an XS interface besides the perl one.

  This works as long as the base extension is loaded with the RTLD_GLOBAL
  flag (usually done with a

  	sub dl_load_flags {0x01}

  in the main .pm file) if you need to use functions defined in the module.

  The basic scheme of operation is to collect information about a module in
  the instance, and then store that data in the Perl library where it may be
  retrieved later. The object can also reformat this information into the
  data structures required by ExtUtils::MakeMaker's WriteMakefile function.

  When creating a new Depends object, you give it a name, which is the name
  of the module you are building. You can also specify the names of modules
  on which this module depends. These dependencies will be loaded
  automatically, and their typemaps, header files, etc merged with your new
  object's stuff. When you store the data for your object, the list of
  dependencies are stored with it, so that another module depending on your
  needn't know on exactly which modules yours depends.

  For example:

    Gtk2 depends on Glib

    Gnome2::Canvas depends on Gtk2

    ExtUtils::Depends->new ('Gnome2::Canvas', 'Gtk2');
       this command automatically brings in all the stuff needed
       for Glib, since Gtk2 depends on it.

  Authors:
  --------
       Paolo Molaro <lupus at debian dot org> wrote the original version for
       Gtk-Perl. muppet <scott at asofyet dot org> rewrote the innards for version
       0.2, borrowing liberally from Paolo's code.


pkgId: e9d0767dd3d2e39656e22dd6501dabc2632cfcca0ded4e03b38c222d5097c25c
name: perl-ExtUtils-F77
arch: src
version: 1.17
epoch: 0
release: 100.1.1
summary: Simple interface to F77 libs
url: http://cpan.org/modules/by-module/ExtUtils/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-ExtUtils-F77-1.17-100.1.1.src.rpm
checksum_type: sha256
description:
  This module tries to figure out how to link C programs with Fortran
  subroutines on your system. Basically one must add a list of Fortran
  runtime libraries. The problem is their location and name varies with
  each OS/compiler combination!



  Authors:
  --------
      Karl Glazebrook <kgb@aaoepp.aao.GOV.AU>


pkgId: f1581603ae9bc96dccb046880d0eff17989ed54b2aae4a0d86694a2ccf5660e5
name: perl-ExtUtils-PkgConfig
arch: src
version: 1.12
epoch: 0
release: 24.1.1
summary: Simplistic interface to pkg-config
url: http://search.cpan.org/dist/ExtUtils-PkgConfig/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-ExtUtils-PkgConfig-1.12-24.1.1.src.rpm
checksum_type: sha256
description:
  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.

  Authors:
  --------
      muppet <scott at asofyet dot org>


pkgId: 6d206d36c477406649683fecc27e75817e45a5529ed796be087d2bf97bd7b878
name: perl-Fennec-Lite
arch: src
version: 0.004
epoch: 0
release: 4.1.1
summary: Minimalist Fennec, the commonly used bits.
url: http://search.cpan.org/dist/Fennec-Lite/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Fennec-Lite-0.004-4.1.1.src.rpm
checksum_type: sha256
description:
  the Fennec manpage does a ton, but it may be hard to adopt it all at once.
  It also is a large project, and has not yet been fully split into component
  projects. Fennec::Lite takes a minimalist approach to do for Fennec what
  Mouse does for Moose.

  Fennec::Lite is a single module file with no non-core dependencies. It can
  easily be used by any project, either directly, or by copying it into your
  project. The file itself is less than 300 lines of code at the time of this
  writing, that includes whitespace.

  This module does not cover any of the more advanced features such as result
  capturing or SPEC workflows. This module only covers test grouping and
  group randomization. You can also use the FENNEC_ITEM variable with a group
  name or line number to run a specific test group only. Test::Builder is
  used under the hood for TAP output.


pkgId: 6312f0a32ce28b7f58105808740dd355c5125f3c0be52c01e06a057aa5c9a0d4
name: perl-File-BaseDir
arch: src
version: 0.03
epoch: 0
release: 4.1.1
summary: Use the Freedesktop.org base directory specification
url: http://search.cpan.org/dist/File-BaseDir/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-BaseDir-0.03-4.1.1.src.rpm
checksum_type: sha256
description:
  This module can be used to find directories and files as specified by the
  Freedesktop.org Base Directory Specification. This specifications gives a
  mechanism to locate directories for configuration, application data and
  cache data. It is suggested that desktop applications for e.g. the Gnome,
  KDE or Xfce platforms follow this layout. However, the same layout can just
  as well be used for non-GUI applications.

  This module forked from the File::MimeInfo manpage.

  This module follows version 0.6 of BaseDir specification.


pkgId: 098e9c930c4610d2feb368f978bc66cc683e66592e49f6f4073a7f3759a61bc7
name: perl-File-Basename-Object
arch: src
version: 0.01
epoch: 0
release: 59.1.1
summary: Object-oriented syntax sugar for File::Basename
url: http://cpan.org/modules/by-module/File/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Basename-Object-0.01-59.1.1.src.rpm
checksum_type: sha256
description:
  File::Basename::Object is an object-oriented wrapper around
  File::Basename. The goal is to allow pathnames to be presented and
  manipulated easily.



  Authors:
  --------
      Tyler "Crackerjack" MacDonald <japh@crackerjack.net>


pkgId: 902c3b1a227ef0932898b57712765edfd68995e9a056067d2286c7c06e5995f2
name: perl-File-Comments
arch: src
version: 0.08
epoch: 0
release: 4.1.1
summary: Recognizes file formats and extracts format-specific comments
url: http://search.cpan.org/dist/File-Comments/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Comments-0.08-4.1.1.src.rpm
checksum_type: sha256
description:
  File::Comments guesses the type of a given file, determines the format used
  for comments, extracts all comments, and returns them as a reference to an
  array of chunks. Alternatively, it strips all comments from a file.

  Currently supported are Perl scripts, C/C++ programs, Java, makefiles,
  JavaScript, Python and PHP.

  The plugin architecture used by File::Comments makes it easy to add new
  formats. To support a new format, a new plugin module has to be installed.
  No modifications to the File::Comments codebase are necessary, new plugins
  will be picked up automatically.

  File::Comments can also be used to simply guess a file's type. It it
  somewhat more flexible than File::MMagic and File::Type. File types in
  File::Comments are typically based on file name suffixes (*.c, *.pl, etc.).
  If no suffix is available, or a given suffix is ambiguous (e.g. if several
  plugins have registered a handler for the same suffix), then the file's
  content is used to narrow down the possibilities and arrive at a decision.

  WARNING: THIS MODULE IS UNDER DEVELOPMENT, QUALITY IS ALPHA. IF YOU FIND
  BUGS, OR WANT TO CONTRIBUTE PLUGINS, PLEASE SEND THEM MY WAY.


pkgId: f740cd5008ddec10f775922a70f4cf442321286090ef906dabac901ce030add7
name: perl-File-Copy-Recursive
arch: src
version: 0.38
epoch: 0
release: 4.1.1
summary: Perl extension for recursively copying files and directories
url: http://search.cpan.org/dist/File-Copy-Recursive/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Copy-Recursive-0.38-4.1.1.src.rpm
checksum_type: sha256
description:
  This module copies and moves directories recursively (or single files,
  well... singley) to an optional depth and attempts to preserve each file or
  directory's mode.


pkgId: 71dc65ddbadf1964fb66c1f7cee105bded920bb95cdb37c1c1bd42b5b02f67e8
name: perl-File-FcntlLock
arch: src
version: 0.14
epoch: 0
release: 2.1.1
summary: File locking with fcntl(2)
url: http://search.cpan.org/dist/File-FcntlLock/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-FcntlLock-0.14-2.1.1.src.rpm
checksum_type: sha256
description:
  File locking in Perl is usually done using the the flock() manpage
  function. Unfortunately, this only allows locks on whole files and is often
  implemented in terms of flock(2), which has some shortcomings.

  Using this module file locking via fcntl(2) can be done.


pkgId: 5711a5f984603e18b601ef8796d2626cb860595c27a76fe60f035dda2d024948
name: perl-File-Find-Rule
arch: src
version: 0.33
epoch: 0
release: 9.1.1
summary: Alternative interface to File::Find
url: http://search.cpan.org/dist/File-Find-Rule/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Find-Rule-0.33-9.1.1.src.rpm
checksum_type: sha256
description:
  File::Find::Rule is a friendlier interface to File::Find. It allows you to build rules which specify the desired files and directories.


pkgId: d2e3d96f10690748c11f49d0294c5abbaab95ef2eb0c63552f073d44eb2bb618
name: perl-File-HomeDir
arch: src
version: 0.99
epoch: 0
release: 4.1.1
summary: Find your home and other directories on any platform
url: http://search.cpan.org/dist/File-HomeDir/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-HomeDir-0.99-4.1.1.src.rpm
checksum_type: sha256
description:
  *File::HomeDir* is a module for locating the directories that are "owned"
  by a user (typicaly your user) and to solve the various issues that arise
  trying to find them consistently across a wide variety of platforms.

  The end result is a single API that can find your resources on any
  platform, making it relatively trivial to create Perl software that works
  elegantly and correctly no matter where you run it.

  This module provides two main interfaces.

  The first is a modern the File::Spec manpage-style interface with a
  consistent OO API and different implementation modules to support various
  platforms. You are *strongly* recommended to use this interface.

  The second interface is for legacy support of the original 0.07 interface
  that exported a 'home()' function by default and tied the '%~' variable.

  It is generally not recommended that you use this interface, but due to
  back-compatibility reasons they will remain supported until at least 2010.

  The '%~' interface has been deprecated. Documentation was removed in 2009,
  Unit test were removed in 2011, usage will issue warnings from 2013, and
  the interface will be removed entirely in 2015 (in line with the general
  Perl toolchain convention of a 10 year support period for legacy APIs that
  are potentially or actually in common use).


pkgId: 80393ed25e0f69ae70cf4876172c4d346697605c40fdb87d41ca061b60f59afa
name: perl-File-LibMagic
arch: src
version: 0.96
epoch: 0
release: 9.1.1
summary: Perlwrapper for libmagic (file-4.x or file-5.x)
url: http://search.cpan.org/dist/File-LibMagic/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-LibMagic-0.96-9.1.1.src.rpm
checksum_type: sha256
description:
  The 'File::LibMagic' is a simple perlinterface to libmagic from the
  file-4.x or file-5.x package from Christos Zoulas
  (ftp://ftp.astron.com/pub/file/).

  You can use the simple Interface like MagicBuffer() or MagicFile(), use the
  functions of libmagic(3) or use the OO-Interface.


pkgId: d676907017ba97abdefa8d60cca8ef484c367e571eddf0524f90fb9dd3c09e23
name: perl-File-Listing
arch: src
version: 6.04
epoch: 0
release: 4.1.1
summary: parse directory listing
url: http://search.cpan.org/dist/File-Listing/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Listing-6.04-4.1.1.src.rpm
checksum_type: sha256
description:
  This module exports a single function called parse_dir(), which can be used
  to parse directory listings.

  The first parameter to parse_dir() is the directory listing to parse. It
  can be a scalar, a reference to an array of directory lines or a glob
  representing a filehandle to read the directory listing from.

  The second parameter is the time zone to use when parsing time stamps in
  the listing. If this value is undefined, then the local time zone is
  assumed.

  The third parameter is the type of listing to assume. Currently supported
  formats are 'unix', 'apache' and 'dosftp'. The default value is 'unix'.
  Ideally, the listing type should be determined automatically.

  The fourth parameter specifies how unparseable lines should be treated.
  Values can be 'ignore', 'warn' or a code reference. Warn means that the
  perl warn() function will be called. If a code reference is passed, then
  this routine will be called and the return value from it will be
  incorporated in the listing. The default is 'ignore'.

  Only the first parameter is mandatory.

  The return value from parse_dir() is a list of directory entries. In a
  scalar context the return value is a reference to the list. The directory
  entries are represented by an array consisting of [ $filename, $filetype,
  $filesize, $filetime, $filemode ]. The $filetype value is one of the
  letters 'f', 'd', 'l' or '?'. The $filetime value is the seconds since Jan
  1, 1970. The $filemode is a bitmask like the mode returned by stat().


pkgId: c5db56e8ce8dec700c4a97b4fd48ccf0607ed028d2f9a0d1d7425d9416b03b9c
name: perl-File-Mork
arch: src
version: 0.3
epoch: 0
release: 9.1.1
summary: a module to read Mozilla URL history files
url: http://search.cpan.org/dist/File-Mork/
rpm_license: MIT
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Mork-0.3-9.1.1.src.rpm
checksum_type: sha256
description:
  This is a module that can read the Mozilla URL history file -- normally
  $HOME/.mozilla/default/*.slt/history.dat -- and extract the id, url, name,
  hostname, first visted dat, last visited date and visit count.

  To find your history file it might be worth using *Mozilla::Backup* which
  has some platform-independent code for finding the profiles of various
  Mozilla-isms (including Firefox, Camino, K-Meleon, etc.).


pkgId: 99b49c5bd42bfdae5baf6c27f077d303c96445a4a394fc2db3c668025db779b2
name: perl-File-Next
arch: src
version: 1.06
epoch: 0
release: 15.1.1
summary: File::Next Perl module
url: http://search.cpan.org/dist/File-Next/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Next-1.06-15.1.1.src.rpm
checksum_type: sha256
description:
  File::Next is an iterator-based module for finding files.  It's
  lightweight, has no dependencies, runs under taint mode, and puts your
  program more directly in control of file selection.


pkgId: 268bf085623ffbd6b414e5f2edf79b0f9572eb971dc08f06948ba61c438cb978
name: perl-File-Path-Tiny
arch: src
version: 0.1
epoch: 0
release: 5.1.1
summary: recursive versions of mkdir() and rmdir() without as much overhead as Fi[cut]
url: http://search.cpan.org/dist/File-Path-Tiny/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Path-Tiny-0.1-5.1.1.src.rpm
checksum_type: sha256
description:
  The goal here is simply to provide recursive versions of the mkdir
  manpage() and the rmdir manpage() with as little code and overhead as
  possible.

  This module is in no way meant to derogate the File::Path manpage and is in
  no way an endorsement to go out and replace all use of the File::Path
  manpage with the File::Path::Tiny manpage.

  the File::Path manpage is very good at what it does but there's simply a
  lot happening that we can do without much of the time.

  Here are some things the File::Path manpage has/does that this module
  attempts to do without:

  * * multiple interfaces

    Backwards compatibility brings in a lot of code and logic that we don't
    need from here on out.

  * * chdir's

    It does a ton of chdir's which could leave you somewhere you're not
    planning on being and requires much more overhead to do.

  * * can croak not allowing you to detect and handle failure

    Just let me handle errors how I want. Don't make my entire app die or
    have to wrap it in an eval

  * * A well intentioned output system

    Just let me do the output how I want. (Nothing, As HTML, print to a
    filehandle, etc...)

  * * A well intentioned and experimental (IE subject to change) error
    handling system.

    Just keep it simple and detect failure via a boolean check and do what I
    want with the error. See the /"How can I make/remove multiple paths?"
    manpage

  * * According to its POD, removing a tree is apparently not safe unless you
    tell it to be with the 'safe' or 'keep_root' attributes.

    Seems like that should just happen, I don't want to worry about
    accidentally removing / when I pass it /tmp


pkgId: 1617bdcf7e7a6c85358d9cd509ac88b453f16e07b0018ee928598d8ea576b35e
name: perl-File-ReadBackwards
arch: src
version: 1.05
epoch: 0
release: 4.1.1
summary: Read a file backwards by lines
url: http://search.cpan.org/dist/File-ReadBackwards
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-ReadBackwards-1.05-4.1.1.src.rpm
checksum_type: sha256
description:
  This module reads a file backwards line by line. It is simple to use, memory
  efficient and fast. It supports both an object and a tied handle interface.

  It is intended for processing log and other similar text files which typically
  have their newest entries appended to them. By default files are assumed to be
  plain text and have a line ending appropriate to the OS. But you can set the
  input record separator string on a per file basis.


pkgId: 5a2df048e98bed8a984c005cb7e0a61d3377cac8f25bd3981fab75a78833aec1
name: perl-File-Remove
arch: src
version: 1.51
epoch: 0
release: 10.1.1
summary: Remove files and directories
url: http://search.cpan.org/dist/File-Remove/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Remove-1.51-10.1.1.src.rpm
checksum_type: sha256
description:
  *File::Remove::remove* removes files and directories. It acts like
  */bin/rm*, for the most part. Although 'unlink' can be given a list of
  files, it will not remove directories; this module remedies that. It also
  accepts wildcards, * and ?, as arguments for filenames.

  *File::Remove::trash* accepts the same arguments as *remove*, with the
  addition of an optional, infrequently used "other platforms" hashref.


pkgId: 4afe8e4a443db935aa9ea77acb5b5b8bbbf36e2a8bf0df4acf917dbeee39b09d
name: perl-File-Rsync
arch: src
version: 0.43
epoch: 0
release: 14.1.1
summary: Perl module interface to rsync
url: http://search.cpan.org/perldoc?File::Rsync
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Rsync-0.43-14.1.1.src.rpm
checksum_type: sha256
description:
  Perl Convenience wrapper for the rsync(1) program. Written for rsync-2.3.2 and
  updated for rsync-2.6.0 but should perform properly with most recent versions.

  Author:
  -------
      Lee Eakin <leakin@dfw.nostrum.com>


pkgId: 6a04a81e500846e29cb8a5c23349cd0f6265a95178ac864d03a523922c26a2be
name: perl-File-ShareDir
arch: src
version: 1.03
epoch: 0
release: 5.1.1
summary: Locate per-dist and per-module shared files
url: http://search.cpan.org/perldoc?File::ShareDir
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-ShareDir-1.03-5.1.1.src.rpm
checksum_type: sha256
description:
  The intent of File::ShareDir is to provide a companion to Class::Inspector and
  File::HomeDir, modules that take a process that is well-known by advanced Perl
  developers but gets a little tricky, and make it more available to the larger
  Perl community.

  Quite often you want or need your Perl module (CPAN or otherwise) to have
  access to a large amount of read-only data that is stored on the file-system at
  run-time.

  On a linux-like system, this would be in a place such as /usr/share, however
  Perl runs on a wide variety of different systems, and so the use of any one
  location is unreliable.

  Perl provides a little-known method for doing this, but almost nobody is aware
  that it exists. As a result, module authors often go through some very strange
  ways to make the data available to their code.

  The most common of these is to dump the data out to an enormous Perl data
  structure and save it into the module itself. The result are enormous
  multi-megabyte .pm files that chew up a lot of memory needlessly.

  Author:
  -------
      Adam Kennedy <adamk@cpan.org>


pkgId: df2e5c9532dc5da9a2deeb6aea406bbb8288fae4bce3f0e8fa42c1094c4d5c45
name: perl-File-ShareDir-Install
arch: src
version: 0.04
epoch: 0
release: 5.1.1
summary: Install shared files
url: http://search.cpan.org/dist/File-ShareDir-Install/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-ShareDir-Install-0.04-5.1.1.src.rpm
checksum_type: sha256
description:
  File::ShareDir::Install allows you to install read-only data files from a
  distribution. It is a companion module to the File::ShareDir manpage, which
  allows you to locate these files after installation.

  It is a port the Module::Install::Share manpage to the ExtUtils::MakeMaker
  manpage with the improvement of only installing the files you want; '.svn'
  and other source-control junk will be ignored.


pkgId: f6a092aef33e3ee16b7be04613128e4d87f91c37fd8b28f2aa5405424507bfab
name: perl-File-Slurp
arch: src
version: 9999.19
epoch: 0
release: 7.1.1
summary: Simple and Efficient Reading/Writing of Complete Files
url: http://search.cpan.org/dist/File-Slurp/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Slurp-9999.19-7.1.1.src.rpm
checksum_type: sha256
description:
  This module provides subs that allow you to read or write entire files with
  one simple call. They are designed to be simple to use, have flexible ways
  to pass in or get the file contents and to be very efficient. There is also
  a sub to read in all the files in a directory other than '.' and '..'

  These slurp/spew subs work for files, pipes and sockets, stdio,
  pseudo-files, and the DATA handle. Read more about why slurping files is a
  good thing in the file 'slurp_article.pod' in the extras/ directory.

  If you are interested in how fast these calls work, check out the
  slurp_bench.pl program in the extras/ directory. It compares many different
  forms of slurping. You can select the I/O direction, context and file
  sizes. Use the --help option to see how to run it.


pkgId: 3103241b676d11ebc57ce6bf6cc600a3887ff2809b433ef60dbc9d0063f29846
name: perl-File-Slurp-Unicode
arch: src
version: 0.7.1
epoch: 0
release: 7.1.1
summary: Reading/Writing of Complete Files with Character Encoding Support
url: http://search.cpan.org/dist/File-Slurp-Unicode/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Slurp-Unicode-0.7.1-7.1.1.src.rpm
checksum_type: sha256
description:
  This module wraps the File::Slurp manpage and adds character encoding
  support through the *'encoding'* parameter. It exports the same functions
  which take all the same parameters as File::Slurp. Please see the the
  File::Slurp manpage documentation for basic usage; only the differences are
  described from here on out.


pkgId: a3f030a2e7e90ee53531a688a7f8fc694b7aadc202f76f25508bc10a8313b8fd
name: perl-File-Sync
arch: src
version: 0.11
epoch: 0
release: 5.1.1
summary: Perl access to fsync() and sync() function calls
url: http://search.cpan.org/dist/File-Sync/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Sync-0.11-5.1.1.src.rpm
checksum_type: sha256
description:
  The fsync() function takes a Perl file handle as its only argument, and
  passes its fileno() to the C function fsync(). It returns _undef_ on
  failure, or _true_ on success.

  The fsync_fd() function is used internally by fsync(); it takes a file
  descriptor as its only argument.

  The sync() function is identical to the C function sync().

  This module does *not* export any methods by default, but fsync() is made
  available as a method of the _FileHandle_ and _IO::Handle_ classes.


pkgId: 01e6d583a91968c609a9eb8d413ee925f3f3600b558f5879d9db5a3cd86ed8be
name: perl-File-Tail
arch: src
version: 0.99.3
epoch: 0
release: 155.1.1
summary: Reading files which are continuously appended
url: http://search.cpan.org/search?module=File::Tail
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Tail-0.99.3-155.1.1.src.rpm
checksum_type: sha256
description:
  The File::Tail module is designed for reading files which are
  continously appended to (the name comes from the tail -f directive).
  Usually such files are logfiles of some description.



  Authors:
  --------
      Matija Grabnar


pkgId: cd95fc449932ce05ea479e355acaeedb8bab7fc6181134af0e5ba449a67d57ba
name: perl-File-Type
arch: src
version: 0.22
epoch: 0
release: 158.1.1
summary: determine file type using magic
url: http://cpan.org/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Type-0.22-158.1.1.src.rpm
checksum_type: sha256
description:
  File::Type uses magic numbers (typically at the start of a file) to
  determine the MIME type of that file.



  Authors:
  --------
      Paul Mison <pmison at fotango dot com>


pkgId: 21cc17555915342bd38b963bd438b5f7a21bd0c1845064b72aaf18600c661247
name: perl-File-Which
arch: src
version: 1.09
epoch: 0
release: 18.1.1
summary: Portable implementation of the `which' utility
url: http://search.cpan.org/dist/File-Which/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-Which-1.09-18.1.1.src.rpm
checksum_type: sha256
description:
  File::Which was created to be able to get the paths to executable programs
  on systems under which the `which' program wasn't implemented in the shell.

  Authors:
  --------
      Per Einar Ellefsen <per.einar@skynet.be>


pkgId: 985515e814c1ee1c6179715091d22c315f1f4c60282b8e16e609816fe7f4c28b
name: perl-File-chdir
arch: src
version: 0.1006
epoch: 0
release: 5.1.1
summary: A more sensible way to change directories
url: http://search.cpan.org/dist/File-chdir/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-chdir-0.1006-5.1.1.src.rpm
checksum_type: sha256
description:
  Perl's 'chdir()' has the unfortunate problem of being very, very, very
  global. If any part of your program calls 'chdir()' or if any library you
  use calls 'chdir()', it changes the current working directory for the
  *whole* program.

  This sucks.

  File::chdir gives you an alternative, '$CWD' and '@CWD'. These two
  variables combine all the power of 'chdir()', the File::Spec manpage and
  the Cwd manpage.


pkgId: 2c898556691ba69ff2993f17c581bd11cb645585906320198798c1e092c2b638
name: perl-File-pushd
arch: src
version: 1.002
epoch: 0
release: 4.1.1
summary: change directory temporarily for a limited scope
url: http://search.cpan.org/dist/File-pushd/
rpm_license: Apache-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-File-pushd-1.002-4.1.1.src.rpm
checksum_type: sha256
description:
  File::pushd does a temporary 'chdir' that is easily and automatically
  reverted, similar to 'pushd' in some Unix command shells. It works by
  creating an object that caches the original working directory. When the
  object is destroyed, the destructor calls 'chdir' to revert to the original
  working directory. By storing the object in a lexical variable with a
  limited scope, this happens automatically at the end of the scope.

  This is very handy when working with temporary directories for tasks like
  testing; a function is provided to streamline getting a temporary directory
  from the File::Temp manpage.

  For convenience, the object stringifies as the canonical form of the
  absolute pathname of the directory entered.


pkgId: b2df6aafe78e0887ebe8b71311d1908f2cd9b6b7eea75ff75f3dcecd596b1b1b
name: perl-FileHandle-Unget
arch: src
version: 0.1623
epoch: 0
release: 19.1.1
summary: FileHandle which supports multi-byte unget
url: http://search.cpan.org/dist/FileHandle-Unget/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-FileHandle-Unget-0.1623-19.1.1.src.rpm
checksum_type: sha256
description:
  FileHandle::Unget operates exactly the same as FileHandle, except that it
  provides a version of ungetc that allows you to unget more than one
  character. It also provides ungets to unget a string.

  This module is useful if the filehandle refers to a stream for which you
  can't just 'seek()' backwards. Some operating systems support multi-byte
  'ungetc()', but this is not guaranteed. Use this module if you want a
  portable solution. In addition, on some operating systems, eof() will not
  be reset if you ungetc after having read to the end of the file.

  NOTE: Using 'sysread()' with 'ungetc()' and other buffering functions is
  still a bad idea.


pkgId: e069d68bcdc75358e26fe56058c555737e6afb87085f6c9837af19cc5981049c
name: perl-Filesys-Df
arch: src
version: 0.92
epoch: 0
release: 11.1.1
summary: Perl extension for filesystem disk space information
url: http://search.cpan.org/dist/Filesys-Df/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Filesys-Df-0.92-11.1.1.src.rpm
checksum_type: sha256
description:
  This module provides a way to obtain filesystem disk space information.
  This is a Unix only distribution. If you want to gather this information
  for Unix and Windows, use Filesys::DfPortable. The only major benefit of
  using Filesys::Df over Filesys::DfPortable, is that Filesys::Df supports
  the use of open filehandles as arguments.

  Authors:
      Ian Guthrie <IGuthrie@aol.com>


pkgId: dba2305583abd089d742b1bac4cb5392a15be98c6c146ced65319a2d8bfbae5e
name: perl-Finance-Quote
arch: src
version: 1.18
epoch: 0
release: 1.2.1
summary: Provides access to time-delayed stockquotes
url: http://finance-quote.sourceforge.net/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Finance-Quote-1.18-1.2.1.src.rpm
checksum_type: sha256
description:
  Finance::Quote provides access to time-delayed stockquotes from a
  number of sources.  After you've installed the pacakage, try 'perldoc
  Finance::Quote' for full information.  Alternatively, you can 'perldoc
  lib/Finance/Quote.pm' before the install.


pkgId: 5dd53bff23d7af073d1f09a459ae3249178cd6e1348851000fb9b6f3469453bf
name: perl-FindBin-Real
arch: src
version: 1.05
epoch: 0
release: 9.1.1
summary: Locate directory of original perl script
url: http://search.cpan.org/dist/FindBin-Real/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-FindBin-Real-1.05-9.1.1.src.rpm
checksum_type: sha256
description:
  Locates the full path to the script bin directory to allow the use of paths
  relative to the bin directory.

  This allows a user to setup a directory tree for some software with
  directories <root>/bin and <root>/lib and then the above example will allow
  the use of modules in the lib directory without knowing where the software
  tree is installed.

  If perl is invoked using the *-e* option or the perl script is read from
  'STDIN' then FindBin sets both 'Bin()' and 'RealBin()' return values to the
  current directory.


pkgId: 3ba2bfc5ffbbe9baf35fb609f744c0526c5abd39efe9771861de8d1923a2e976
name: perl-Font-AFM
arch: src
version: 1.20
epoch: 0
release: 44.1.1
summary: Interface to Adobe Font Metrics Files
url: http://cpan.org/authors/id/G/GA/GAAS
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Font-AFM-1.20-44.1.1.src.rpm
checksum_type: sha256
description:
  This module implements the Font::AFM class. Objects of this class are
  initialized from an AFM file and allow you to obtain information about
  the font and the metrics of the various glyphs in the font.



  Authors:
  --------
      Gisle Aas <gisle@aas.no>


pkgId: 7cbd43f2e0e8db735a69dfb53025374e69cb1794c1ed86189e33f040ac60830c
name: perl-Font-FreeType
arch: src
version: 0.03
epoch: 0
release: 98.1.1
summary: Read font files and render glyphs from Perl using FreeType2
url: http://search.cpan.org/~geoffr/Font-FreeType-0.03/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: System/X11/Fonts
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Font-FreeType-0.03-98.1.1.src.rpm
checksum_type: sha256
description:
  Read font files and render glyphs from Perl using FreeType2



  Authors:
  --------
      Geoff Richards <geoff@laxan.com>


pkgId: 25352a829ad60b2d3365207cfcdc948f977e03dcd1df902d74e645e01d17a878
name: perl-Font-TTF
arch: src
version: 0.48
epoch: 0
release: 8.1.1
summary: Perl module for TrueType Font hacking
url: http://search.cpan.org/dist/Font-TTF/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Font-TTF-0.48-8.1.1.src.rpm
checksum_type: sha256
description:
  This module allows you to do almost anything to a TrueType/OpenType Font
  including modify and inspect nearly all tables.


pkgId: 7efbf7a192d320d7c7d65ce5c436a3ab48e663fe734faa0e5affc50973dbb8ed
name: perl-FreezeThaw
arch: src
version: 0.5001
epoch: 0
release: 14.1.1
summary: Converting Perl structures to strings and back
url: http://search.cpan.org/dist/FreezeThaw
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-FreezeThaw-0.5001-14.1.1.src.rpm
checksum_type: sha256
description:
  Converts data to/from stringified form, appropriate for saving-to/reading-from
  permanent storage.

  Deals with objects, circular lists, repeated appearence of the same refence.
  Does not deal with overloaded stringify operator yet.

    Author:	Ilya Zakharevich


pkgId: 33dec4c88a58e7d613dcb0f191b71d1430034e71aac2ceed0ab740aaeb2a12b1
name: perl-GD
arch: src
version: 2.46
epoch: 0
release: 11.1.1
summary: Interface to Gd Graphics Library
url: http://search.cpan.org/dist/GD/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GD-2.46-11.1.1.src.rpm
checksum_type: sha256
description:
  *GD.pm* is a Perl interface to Thomas Boutell's gd graphics library
  (version 2.01 or higher; see below). GD allows you to create color drawings
  using a large number of graphics primitives, and emit the drawings as PNG
  files.


pkgId: 2f5dc9307770b3749c7992df85266083ebee6f17845330cae806364aa842a26f
name: perl-GD-Barcode
arch: src
version: 1.15
epoch: 0
release: 20.1.1
summary: Create barcode image with GD
url: http://search.cpan.org/dist/GD-Barcode/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GD-Barcode-1.15-20.1.1.src.rpm
checksum_type: sha256
description:
  GD::Barcode is a subclass of GD and allows you to create barcode image with
  GD. This module based on "Generate Barcode Ver 1.02 By Shisei Hanai
  97/08/22".

  From 1.14, you can use this module even if no GD (except plot method).


pkgId: 27210036ca437d4d5c1fa384074f00b1fa5710006e6cf01adf8e374db2ace476
name: perl-GD-Graph3d
arch: src
version: 0.63
epoch: 0
release: 263.1.1
summary: 3d extension for perl-GDGraph
url: http://cpan.org/modules/by-module/GD/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GD-Graph3d-0.63-263.1.1.src.rpm
checksum_type: sha256
description:
  This is the GD::Graph3d extensions module. It provides 3D graphs for
  the GD::Graph module by Martien Verbruggen, which in turn generates
  graph using Lincoln Stein's GD.pm.



  Authors:
  --------
      Jeremy Wadsack <dgsupport@wadsack-allen.com>


pkgId: d5badbb758ac10d8f1d6c3abe371f497fe62226d3103ff09961d2a3e87b76bb9
name: perl-GDGraph
arch: src
version: 1.44
epoch: 0
release: 195.1.1
summary: Package to generate charts, using Lincoln Stein's GD.pm
url: http://cpan.org/modules/by-module/GD/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GDGraph-1.44-195.1.1.src.rpm
checksum_type: sha256
description:
  This is GDGraph, a package to generate charts, using Lincoln Stein's
  GD.pm. See the documentation for some history and more information.


pkgId: b28f0d837725ff5d76580033578f70bd128dd4b0296710d6451b6516dac0d2e2
name: perl-GDTextUtil
arch: src
version: 0.86
epoch: 0
release: 91.1.1
summary: text utilities for use with the GD drawing package
url: http://cpan.org/modules/by-module/GD/
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GDTextUtil-0.86-91.1.1.src.rpm
checksum_type: sha256
description:
  This package provides three modules that make it possible to work with
  internal GD fonts as well as TrueType fonts, without having to worry
  about different interface functions to call. Apart from an abstract
  interface to all font types and strings for GD, this library also
  provides some utility in aligning and wrapping your string.



  Authors:
  --------
      Martien Verbruggen <mgjv@comdyn.com.au>


pkgId: f412522cebfb8a7cd320a531ec5dcbb6c4929d35a332ee37bd85d10db483c2fd
name: perl-Geo-Coordinates-UTM
arch: src
version: 0.09
epoch: 0
release: 9.1.1
summary: Perl extension for Latitiude Longitude conversions
url: http://search.cpan.org/dist/Geo-Coordinates-UTM/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Geo-Coordinates-UTM-0.09-9.1.1.src.rpm
checksum_type: sha256
description:
  This module will translate latitude longitude coordinates to Universal
  Transverse Mercator(UTM) coordinates and vice versa.

  Authors:
  --------
      Graham Crookham <grahamc@cpan.org>


pkgId: 0611e4cd2994f604fc9d8fe612be8ab6c72a6a0f17e926ffd01735060823478b
name: perl-Getopt-ArgvFile
arch: src
version: 1.11
epoch: 0
release: 4.1.1
summary: Perl Module to interpolate Script Options from Files into @ARGV
url: http://search.cpan.org/dist/Getopt-ArgvFile/
rpm_license: Artistic-1.0 or Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Getopt-ArgvFile-1.11-4.1.1.src.rpm
checksum_type: sha256
description:
  This module simply interpolates option file hints in @ARGV by the contents of
  the pointed files. This enables option reading from files instead of or
  additional to the usual reading from the command line.

  Alternatively, you can process any array instead of @ARGV which is used by
  default and mentioned mostly in this manual.

  The interpolated @ARGV could be subsequently processed by the usual option
  handling, e.g. by a Getopt::xxx module. Getopt::ArgvFile does not perform any
  option handling itself, it only prepares the array @ARGV.


pkgId: ed72772295a0ffccdf76b5aafaf4373dc638822e3849c844ffea1b161a2a4f99
name: perl-Getopt-Long-Descriptive
arch: src
version: 0.091
epoch: 0
release: 4.1.1
summary: Getopt::Long, but simpler and more powerful
url: http://search.cpan.org/dist/Getopt-Long-Descriptive/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Getopt-Long-Descriptive-0.091-4.1.1.src.rpm
checksum_type: sha256
description:
  Getopt::Long::Descriptive is yet another Getopt library. It's built atop
  Getopt::Long, and gets a lot of its features, but tries to avoid making you
  think about its huge array of options.

  It also provides usage (help) messages, data validation, and a few other
  useful features.


pkgId: 026911b14fefaad8cc18d984f3d039ef4b60143a8814098b1e5d7ff233fdb98e
name: perl-Getopt-Mixed
arch: src
version: 1.10
epoch: 0
release: 20.1.1
summary: GNU-style option processing (long and short) for Perl
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Getopt-Mixed-1.10-20.1.1.src.rpm
checksum_type: sha256
description:
  This module provides GNU-style option processing for Perl 5 scripts,
  with both long and short options.



  Authors:
  --------
      Christopher J. Madsen <ac608@yfn.ysu.edu>


pkgId: 261cd9354f1699ec7676c26c83a46b7d643acf6d05f9e4f82066a60e971bfaac
name: perl-Glib
arch: src
version: 1.250
epoch: 0
release: 5.1.1
summary: Glib Perl module
url: http://cpan.org/modules/by-module/Glib/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Glib-1.250-5.1.1.src.rpm
checksum_type: sha256
description:
  This module provides perl access to GLib and GLib's GObject libraries.
  GLib is a portability and utility library; GObject provides a generic
  type system with inheritance and a powerful signal system.  Together
  these libraries are used as the foundation for many of the libraries
  that make up the Gnome environment, and are used in many unrelated
  projects.


pkgId: 8f3bfb60d4ea7fddb74de5b37c5dab98817f705c09d5bab966a42e6c4689e3c6
name: perl-Gnome2
arch: src
version: 1.042
epoch: 0
release: 8.1.1
summary: Gnome2 Perl module
url: http://search.cpan.org/dist/Gnome2/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gnome2-1.042-8.1.1.src.rpm
checksum_type: sha256
description:
  Perl bindings to the 2.x series of the Gnome widget set.  This module allows
  you to write graphical user interfaces in a perlish and object-oriented way,
  freeing you from the casting and memory management in C, yet remaining very
  close in spirit to original API.


pkgId: 143ff89d0f73bb540faf90971146c88ce2f74961386697cc8e0489b00814ca2c
name: perl-Gnome2-Canvas
arch: src
version: 1.002
epoch: 0
release: 8.1.1
summary: Gnome2-Canvas Perl module
url: http://search.cpan.org/dist/Gnome2-Canvas/
rpm_license: LGPL-2.0+ and GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Languages/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gnome2-Canvas-1.002-8.1.1.src.rpm
checksum_type: sha256
description:
  The Gnome2::Canvas module allows a perl developer to use the GnomeCanvas
  widget with Gtk2-Perl.  Find out more about Gnome+ at http://www.gnome.org.

  Like the Gtk2 module on which it depends, Gnome2::Canvas follows the C API
  of libgnomecanvas-2.0 as closely as possible while still being perlish.
  Thus, the C API reference remains the canonical documentation.

  To discuss gtk2-perl, ask questions and flame/praise the authors,
  join gtk-perl-list@gnome.org at lists.gnome.org.

  Also have a look at the gtk2-perl website and sourceforge project page,
  http://gtk2-perl.sourceforge.net


pkgId: f02a3d480486f1c380062a4f472d4b6ef228e824735b03dcace1b824dd6ad89a
name: perl-Gnome2-VFS
arch: src
version: 1.081
epoch: 0
release: 9.1.1
summary: Gnome2-VFS Perl module
url: http://search.cpan.org/dist/Gnome2-VFS/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Languages/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gnome2-VFS-1.081-9.1.1.src.rpm
checksum_type: sha256
description:
  This module allows you to use the GNOME Virtual File System library
  (libgnomevfs for short) from Perl.

  The canonical API documentation can be found at

    http://developer.gnome.org/doc/API/2.0/gnome-vfs-2.0/index.html

  Gnome2::VFS also comes with automatically generated API documentation.  To
  access its index, use:

    perldoc Gnome2::VFS::index


pkgId: 5000ef2fddc8c48fd76823d6e34bfbaa0b16ca48c08350dd610897feffb59001
name: perl-Gnome2-Wnck
arch: src
version: 0.16
epoch: 0
release: 10.1.1
summary: Perl interface to the Window Navigator Construction Kit
url: http://search.cpan.org/dist/Gnome2-Wnck/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gnome2-Wnck-0.16-10.1.1.src.rpm
checksum_type: sha256
description:
  This module allows you to use the Window Navigator Construction Kit library
  (libwnck for short) from Perl.

  The index of the automatically generated API documentation can be accessed
  with:

    perldoc Gnome2::Wnck::index


pkgId: c82a5b5c358c4bfa7c7f8fd0e4d1444240c05a7155961fbacdb9b0ae007c831b
name: perl-GnuPG-Interface
arch: src
version: 0.44
epoch: 0
release: 7.1.1
summary: Perl interface to GnuPG
url: http://search.cpan.org/dist/GnuPG-Interface/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GnuPG-Interface-0.44-7.1.1.src.rpm
checksum_type: sha256
description:
  GnuPG::Interface and its associated modules are designed to provide an
  object-oriented method for interacting with GnuPG, being able to perform
  functions such as but not limited to encrypting, signing, decryption,
  verification, and key-listing parsing.


pkgId: 91152f0b6149151a400921e69d8166b6e60f7d6fbcaa1025e3d927b594fdf9f0
name: perl-Graph
arch: src
version: 0.94
epoch: 0
release: 9.1.1
summary: Graph data structures and algorithms
url: http://search.cpan.org/dist/Graph/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Graph-0.94-9.1.1.src.rpm
checksum_type: sha256
description:
  Graph::Directed allows you to create directed graphs.
  For the available methods, see Graph.
  http://search.cpan.org/~jhi/Graph-0.94/lib/Graph.pod

  Authors:
  --------
      Jarkko Hietaniemi <jhi@iki.fi>


pkgId: 0ed806d9b6a6d02370e8d0072cb3599b99d252ac25ce54fc3dac5c711e308662
name: perl-GraphViz
arch: src
version: 2.08
epoch: 0
release: 5.1.1
summary: Interface to AT&T's GraphViz. Deprecated. See GraphViz2
url: http://search.cpan.org/dist/GraphViz/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-GraphViz-2.08-5.1.1.src.rpm
checksum_type: sha256
description:
  This module provides an interface to layout and image generation of
  directed and undirected graphs in a variety of formats (PostScript, PNG,
  etc.) using the "dot", "neato", "twopi", "circo" and "fdp" programs from
  the GraphViz project (http://www.graphviz.org/ or
  http://www.research.att.com/sw/tools/graphviz/).

  GraphViz is deprecated in favour of the GraphViz2 manpage.


pkgId: c9923677868ef446b8e53096d6346514f37990c4df0570691d4549ff3f2f055d
name: perl-Gravatar-URL
arch: src
version: 1.06
epoch: 0
release: 4.1.1
summary: Make URLs for Gravatars from an email address
url: http://search.cpan.org/dist/Gravatar-URL/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gravatar-URL-1.06-4.1.1.src.rpm
checksum_type: sha256
description:
  A Gravatar is a Globally Recognized Avatar for a given email address. This
  allows you to have a global picture associated with your email address. You
  can look up the Gravatar for any email address by constructing a URL to get
  the image from the gravatar.com manpage. This module does that.

  Examples of use include the author faces on the http://search.cpan.org
  manpage.

  See the http://gravatar.com manpage for more info.


pkgId: b15eaa3e44722c2d9807e0c7ce09ef3853f801f00be81ce48aa2e72feac5478d
name: perl-Gtk2
arch: src
version: 1.242
epoch: 0
release: 4.2.1
summary: Perl interface to the 2
url: http://search.cpan.org/dist/Gtk2/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gtk2-1.242-4.2.1.src.rpm
checksum_type: sha256
description:
  Perl bindings to the 2.x series of the Gtk+ widget set.  This module
  allows you to write graphical user interfaces in a perlish and
  object-oriented way, freeing you from the casting and memory management
  in C, yet remaining very close in spirit to original API.


pkgId: ff9121a336e834446a1b021deb0684c221a95777f115bb68a0e847059987b2da
name: perl-Gtk2-Unique
arch: src
version: 0.05
epoch: 0
release: 8.1.1
summary: Perl bindings for the C library "libunique"
url: http://mirrors.ibiblio.org/CPAN/modules/by-module/Gtk2/
rpm_license: LGPL-2.1+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Gtk2-Unique-0.05-8.1.1.src.rpm
checksum_type: sha256
description:
  Perl bindings for the C library "libunique" that provides a mechanism for
  writing single instance applications. If you launch a single instance
  application twice, the second instance will either just quit or will send a
  message to the running instance.


pkgId: 580faeb2fc2962f69840bb5b6eec09ee1b2a78b9ed71a730c5c1fa0bd7497ab6
name: perl-HTML-Clean
arch: src
version: 0.8
epoch: 0
release: 897.1.1
summary: Cleans up HTML code for web browsers, not humans
url: http://cpan.org/modules/by-module/HTML/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build34
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Clean-0.8-897.1.1.src.rpm
checksum_type: sha256
description:
  The majority of the web pages of the internet today are much larger
  than they need to be.  The reason for this is that HTML tends to be
  stored in a human readable format, with indenting, newlines and
  comments.

  However, all of these comments, whitespace etc. are ignored by the
  browser, and needlessly lengthen download times.

  Second, many people are using WYSIWYG HTML editors these days. This
  makes creating content easy.  However these editors can cause a number
  of compatibility problems by tying themselves to a particular browser
  or operating system.



  Authors:
  --------
      Paul Lindner <paul.lindner@itu.int>


pkgId: 75e58864fd698a8ba91911482a468786c74526f650fe583ecc3843a03b5c5ecb
name: perl-HTML-Element-Extended
arch: src
version: 1.18
epoch: 0
release: 9.1.1
summary: Extension for HTML::Element
url: http://search.cpan.org/dist/HTML-Element-Extended/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Element-Extended-1.18-9.1.1.src.rpm
checksum_type: sha256
description:
  HTML-Element-Extended is a package of several enhanced HTML::Element
  classes, most of which arose during the effort to implement an
  HTML::Element based table class.

  The modules are:
          HTML::ElementTable
          HTML::ElementSuper
          HTML::ElementGlob
          HTML::ElementRaw

  The resulting functionality enables:
          tables
          element globs
          element coordinates
          content replacement
          content wrapping
          element cloning
          raw HTML string adoption


pkgId: c63a69e533eea6bc4c55b51324d51723db6b388c3a3174040693f85e5217bf61
name: perl-HTML-FillInForm
arch: src
version: 2.1
epoch: 0
release: 81.1.1
summary: Perl module HTML::FillInForm
url: http://cpan.org/modules/by-module/HTML/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-FillInForm-2.1-81.1.1.src.rpm
checksum_type: sha256
description:
  This module automatically inserts data from a previous HTML form into
  the HTML input and select tags. It is a subclass of HTML::Parser and
  uses it to parse the HTML and insert the values into the form tags.


pkgId: 14ec950dfd7bdad46ff2a4155642df1942eb82edca90e0b84ac7e85922472b29
name: perl-HTML-Form
arch: src
version: 6.01
epoch: 0
release: 4.1.1
summary: Class that represents an HTML form element
url: http://search.cpan.org/dist/HTML-Form/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Form-6.01-4.1.1.src.rpm
checksum_type: sha256
description:
  Objects of the 'HTML::Form' class represents a single HTML '<form> ...
  </form>' instance. A form consists of a sequence of inputs that usually
  have names, and which can take on various values. The state of a form can
  be tweaked and it can then be asked to provide 'HTTP::Request' objects that
  can be passed to the request() method of 'LWP::UserAgent'.


pkgId: 567d25e77f0cc27041c12ca5ab4be828c3f4deeb21a82e3fed2990409aa614a4
name: perl-HTML-FormHandler
arch: src
version: 0.36003
epoch: 0
release: 4.1.1
summary: HTML forms using Moose
url: http://search.cpan.org/dist/HTML-FormHandler/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-FormHandler-0.36003-4.1.1.src.rpm
checksum_type: sha256
description:
  *** Although documentation in this file provides some overview, it is
  mainly intended for API documentation. See the
  HTML::FormHandler::Manual::Intro manpage for a more detailed introduction.

  HTML::FormHandler maintains a clean separation between form construction
  and form rendering. It allows you to define your forms and fields in a
  number of flexible ways. Although it provides renderers for HTML, you can
  define custom renderers for any kind of presentation.

  HTML::FormHandler allows you to define form fields and validators. It can
  be used for both database and non-database forms, and will automatically
  update or create rows in a database. It can be used to process structured
  data that doesn't come from an HTML form.

  One of its goals is to keep the controller/application program interface as
  simple as possible, and to minimize the duplication of code. In most cases,
  interfacing your controller to your form is only a few lines of code.

  With FormHandler you'll never spend hours trying to figure out how to make
  a simple HTML change that would take one minute by hand. Because you CAN do
  it by hand. Or you can automate HTML generation as much as you want, with
  template widgets or pure Perl rendering classes, and stay completely in
  control of what, where, and how much is done automatically. You can define
  custom renderers and display your rendered forms however you want.

  You can split the pieces of your forms up into logical parts and compose
  complete forms from FormHandler classes, roles, fields, collections of
  validations, transformations and Moose type constraints. You can write
  custom methods to process forms, add any attribute you like, use Moose
  method modifiers. FormHandler forms are Perl classes, so there's a lot of
  flexibility in what you can do.

  HTML::FormHandler provides rendering through roles which are applied to
  form and field classes (although there's no reason you couldn't write a
  renderer as an external object either). There are currently two flavors:
  all-in-one solutions like the HTML::FormHandler::Render::Simple manpage and
  the HTML::FormHandler::Render::Table manpage that contain methods for
  rendering field widget classes, and the the HTML::FormHandler::Widget
  manpage roles, which are more atomic roles which are automatically applied
  to fields and form if a 'render' method does not already exist. See the
  HTML::FormHandler::Manual::Rendering manpage for more details. (And you can
  easily use hand-build forms - FormHandler doesn't care.)

  The typical application for FormHandler would be in a Catalyst,
  DBIx::Class, Template Toolkit web application, but use is not limited to
  that. FormHandler can be used in any Perl application.

  More Formhandler documentation and a tutorial can be found in the manual at
  the HTML::FormHandler::Manual manpage.


pkgId: 649721389caf93923404f15b770161742af241c31bdc655ff32fe6c6c26060e9
name: perl-HTML-Parser
arch: src
version: 3.69
epoch: 0
release: 14.1.1
summary: HTML parser class
url: http://search.cpan.org/dist/HTML-Parser/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Parser-3.69-14.1.1.src.rpm
checksum_type: sha256
description:
  Objects of the HTML::Parser class will recognize markup and separate it
  from plain text (alias data content) in HTML documents. As different
  kinds of markup and text are recognized, the corresponding event handlers
  are invoked.

  HTML::Parser is not a generic SGML parser. We have tried to make it able to
  deal with the HTML that is actually "out there", and it normally parses as
  closely as possible to the way the popular web browsers do it instead of
  strictly following one of the many HTML specifications from W3C. Where
  there is disagreement, there is often an option that you can enable to
  get the official behaviour.

  The document to be parsed may be supplied in arbitrary chunks. This makes
  on-the-fly parsing as documents are received from the network possible.

  If event driven parsing does not feel right for your application, you might
  want to use HTML::PullParser. This is an HTML::Parser subclass that allows
  a more conventional program structure.


pkgId: 424973b5fdd98572ddec883f2745a4f7ce3827ce3ceb51e9bc3d3f11ddfc6365
name: perl-HTML-RewriteAttributes
arch: src
version: 0.05
epoch: 0
release: 2.1.1
summary: Concise attribute rewriting
url: http://search.cpan.org/dist/HTML-RewriteAttributes/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-RewriteAttributes-0.05-2.1.1.src.rpm
checksum_type: sha256
description:
  HTML::RewriteAttributes is designed for simple yet powerful HTML attribute
  rewriting.

  You simply specify a callback to run for each attribute and we do the rest for
  you.

  This module is designed to be subclassable to make handling special cases
  eaiser. See the source for methods you can override.

  Author:
  -------
      Shawn M Moore, <sartak@bestpractical.com>


pkgId: 21c9d0f1c785f4f6527e061f40bb19791d70bb9f99c7b33767f5ac58b82ac589
name: perl-HTML-Scrubber
arch: src
version: 0.09
epoch: 0
release: 8.1.1
summary: Perl extension for scrubbing/sanitizing html
url: http://search.cpan.org/dist/HTML-Scrubber/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Scrubber-0.09-8.1.1.src.rpm
checksum_type: sha256
description:
  If you wanna "scrub" or "sanitize" html input in a reliable and flexible
  fashion, then this module is for you.

  I wasn't satisfied with HTML::Sanitizer because it is based on
  HTML::TreeBuilder, so I thought I'd write something similar that works
  directly with HTML::Parser.


pkgId: ebf02617880307596b325ea17d6b4d986ecaf879e1971639dabf251987d039ef
name: perl-HTML-SimpleParse
arch: src
version: 0.12
epoch: 0
release: 278.1.1
summary: a bare-bones HTML parser
url: http://search.cpan.org/perldoc?HTML::SimpleParse
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-SimpleParse-0.12-278.1.1.src.rpm
checksum_type: sha256
description:
  This is the HTML::SimpleParse module.  It is a bare-bones HTML parser,
  similar to HTML::Parser, but with a couple important distinctions:

  First, HTML::Parser knows which tags can contain other tags, which
  start tags have corresponding end tags, which tags can exist only in
  the <HEAD> portion of the document, and so forth.  HTML::SimpleParse
  does not know any of these things.  It just finds tags and text in the
  HTML you give it, it does not care about the specific content of these
  tags (though it does distiguish between different _types_ of tags, such
  as comments, starting tags like <b>, ending tags like </b>, and so on).

  Second, HTML::SimpleParse does not create a hierarchical tree of HTML
  content, but rather a simple linear list.  It does not pay any
  attention to balancing start tags with corresponding end tags, or which
  pairs of tags are inside other pairs of tags.

  Because of these characteristics, you can make a very effective HTML
  filter by sub-classing HTML::SimpleParse.



  Authors:
  --------
      Ken Williams <ken@forum.swarthmore.edu>


pkgId: 8d72d42fdd3d531c5a1086ba993d65d28cb8d436ba5dee855276fbe3a0df3f6f
name: perl-HTML-TableExtract
arch: src
version: 2.11
epoch: 0
release: 4.1.1
summary: Perl module for extracting the content contained in tables within an HTM[cut]
url: http://search.cpan.org/dist/HTML-TableExtract/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-TableExtract-2.11-4.1.1.src.rpm
checksum_type: sha256
description:
  HTML::TableExtract is a subclass of HTML::Parser that serves to extract the
  information from tables of interest contained within an HTML document. The
  information from each extracted table is stored in table objects. Tables
  can be extracted as text, HTML, or HTML::ElementTable structures (for
  in-place editing or manipulation).

  There are currently four constraints available to specify which tables you
  would like to extract from a document: _Headers_, _Depth_, _Count_, and
  _Attributes_.

  _Headers_, the most flexible and adaptive of the techniques, involves
  specifying text in an array that you expect to appear above the data in the
  tables of interest. Once all headers have been located in a row of that
  table, all further cells beneath the columns that matched your headers are
  extracted. All other columns are ignored: think of it as vertical slices
  through a table. In addition, TableExtract automatically rearranges each
  row in the same order as the headers you provided. If you would like to
  disable this, set _automap_ to 0 during object creation, and instead rely
  on the column_map() method to find out the order in which the headers were
  found. Furthermore, TableExtract will automatically compensate for cell
  span issues so that columns are really the same columns as you would
  visually see in a browser. This behavior can be disabled by setting the
  _gridmap_ parameter to 0. HTML is stripped from the entire textual content
  of a cell before header matches are attempted -- unless the _keep_html_
  parameter was enabled.

  _Depth_ and _Count_ are more specific ways to specify tables in relation to
  one another. _Depth_ represents how deeply a table resides in other tables.
  The depth of a top-level table in the document is 0. A table within a
  top-level table has a depth of 1, and so on. Each depth can be thought of
  as a layer; tables sharing the same depth are on the same layer. Within
  each of these layers, _Count_ represents the order in which a table was
  seen at that depth, starting with 0. Providing both a _depth_ and a _count_
  will uniquely specify a table within a document.

  _Attributes_ match based on the attributes of the html <table> tag, for
  example, boder widths or background color.

  Each of the _Headers_, _Depth_, _Count_, and _Attributes_ specifications
  are cumulative in their effect on the overall extraction. For instance, if
  you specify only a _Depth_, then you get all tables at that depth (note
  that these could very well reside in separate higher- level tables
  throughout the document since depth extends across tables). If you specify
  only a _Count_, then the tables at that _Count_ from all depths are
  returned (i.e., the _n_th occurrence of a table at each depth). If you only
  specify _Headers_, then you get all tables in the document containing those
  column headers. If you have specified multiple constraints of _Headers_,
  _Depth_, _Count_, and _Attributes_, then each constraint has veto power
  over whether a particular table is extracted.

  If no _Headers_, _Depth_, _Count_, or _Attributes_ are specified, then all
  tables match.

  When extracting only text from tables, the text is decoded with
  HTML::Entities by default; this can be disabled by setting the _decode_
  parameter to 0.


pkgId: f5984208a058f791e2dff77d079a3768febb096a125d0aab4583a29b39131403
name: perl-HTML-Tagset
arch: src
version: 3.20
epoch: 0
release: 67.1.1
summary: Data tables useful in parsing HTML
url: http://search.cpan.org/dist/HTML-Tagset/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Tagset-3.20-67.1.1.src.rpm
checksum_type: sha256
description:
  This module contains several data tables useful in various kinds of HTML
  parsing operations.

  Note that all tag names used are lowercase.

  In the following documentation, a "hashset" is a hash being used as a set
  -- the hash conveys that its keys are there, and the actual values
  associated with the keys are not significant. (But what values are there,
  are always true.)


pkgId: 670346368968de407f62c38fb95c68f6ce166d6a76f07db02028e9f734b0110f
name: perl-HTML-Template
arch: src
version: 2.9
epoch: 0
release: 125.1.1
summary: This Module Attempts to make using HTML Templates Simple and Natural
url: http://cpan.org/modules/by-module/HTML/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Template-2.9-125.1.1.src.rpm
checksum_type: sha256
description:
  This allows you to separate design - the HTML - from the data, which
  you generate in the Perl script.



  Authors:
  --------
      Sam Tregar <sam@tregar.com>


pkgId: 9c86c317683ed2dbfab737c0e4cc5a9d67e9dee602a630a32fda89a3e37f09d1
name: perl-HTML-Template-Expr
arch: src
version: 0.07
epoch: 0
release: 145.1.1
summary: This Module Provides an Extension to HTML::Template
url: http://cpan.org/modules/by-module/HTML/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Template-Expr-0.07-145.1.1.src.rpm
checksum_type: sha256
description:
  This module provides an extension to HTML::Template which allows
  expressions in the template syntax.

  Expression support includes comparisons, math operations, string
  operations, and a mechanism to allow you to add your own functions at
  runtime.



  Authors:
  --------
      Sam Tregar <sam@tregar.com>


pkgId: 58e9937ab27d273b536ee76ed1d912ba809f3047df99fd67312c3dc61612bb41
name: perl-HTML-Template-JIT
arch: src
version: 0.05
epoch: 0
release: 154.1.1
summary: Just-In-Time Compiler for HTML Templates
url: http://www.cpan.org/modules/by-module/HTML
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Template-JIT-0.05-154.1.1.src.rpm
checksum_type: sha256
description:
  This is a just in time compiler for the HTML Template module. Makes the
  use of templates very fast.



  Authors:
  --------
      Sam Tregar <sam@tregar.com>


pkgId: 80acc76769d0b42381a07b8fa620458cc0f04440cfdf8bd146fe510e7e846fce
name: perl-HTML-Tidy
arch: src
version: 1.54
epoch: 0
release: 2.1.1
summary: (X)HTML validation in a Perl object
url: http://search.cpan.org/dist/HTML-Tidy/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Tidy-1.54-2.1.1.src.rpm
checksum_type: sha256
description:
  'HTML::Tidy' is an HTML checker in a handy dandy object. It's meant as a
  replacement for HTML::Lint. If you're currently an HTML::Lint user looking
  to migrate, see the section the /Converting from HTML::Lint manpage.


pkgId: bd72c05fa8db73005ad20c092202ac74d22af44d3b4aab8f2b16a2009af944d4
name: perl-HTML-TokeParser-Simple
arch: src
version: 3.15
epoch: 0
release: 15.1.1
summary: Easy to use HTML::TokeParser interface
url: http://search.cpan.org/dist/HTML-TokeParser-Simple/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-TokeParser-Simple-3.15-15.1.1.src.rpm
checksum_type: sha256
description:
  HTML::TokeParser::Simple is a subclass of HTML::TokeParser that uses
  easy-to-remember method calls to work with the tokens.  Rather than
  try to remember a bunch of array indices or try to write a bunch of
  constants for them, you can now do something like:

   $token->is_start_tag( 'form' )

  Instead of

   $token->[0] eq 'S' and $token->[1] eq 'form'

  Authors:
  --------
      Curtis "Ovid" Poe <poec@yahoo.com>


pkgId: cf3ef7b305eb1f00530a10788d351255a59891f35381c9a263917ad84ee39b94
name: perl-HTML-Tree
arch: src
version: 4.2
epoch: 0
release: 15.1.1
summary: Build and scan parse-trees of HTML
url: http://search.cpan.org/dist/HTML-Tree/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTML-Tree-4.2-15.1.1.src.rpm
checksum_type: sha256
description:
  HTML-Tree is a suite of Perl modules for making parse trees out of HTML
  source. It consists of mainly two modules, whose documentation you should
  refer to: HTML::TreeBuilder and HTML::Element.

  HTML::TreeBuilder is the module that builds the parse trees. (It uses
  HTML::Parser to do the work of breaking the HTML up into tokens.)

  The tree that TreeBuilder builds for you is made up of objects of the class
  HTML::Element.

  If you find that you do not properly understand the documentation for
  HTML::TreeBuilder and HTML::Element, it may be because you are unfamiliar
  with tree-shaped data structures, or with object-oriented modules in
  general. Sean Burke has written some articles for _The Perl Journal_
  ('www.tpj.com') that seek to provide that background. The full text of
  those articles is contained in this distribution, as:

  * HTML::Tree::AboutObjects

    "User's View of Object-Oriented Modules" from TPJ17.

  * HTML::Tree::AboutTrees

    "Trees" from TPJ18

  * HTML::Tree::Scanning

    "Scanning HTML" from TPJ19

  Readers already familiar with object-oriented modules and tree-shaped data
  structures should read just the last article. Readers without that
  background should read the first, then the second, and then the third.

  new
      Redirects to HTML::TreeBuilder::new

  new_from_file
      Redirects to HTML::TreeBuilder::new_from_file

  new_from_content
      Redirects to HTML::TreeBuilder::new_from_content


pkgId: f76ce2d9140471b1438aa925fd9808a041c49927cc2a8cfa2b9aabbce70dfc47
name: perl-HTTP-Body
arch: src
version: 1.15
epoch: 0
release: 4.1.1
summary: HTTP Body Parser
url: http://search.cpan.org/dist/HTTP-Body/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Body-1.15-4.1.1.src.rpm
checksum_type: sha256
description:
  HTTP::Body parses chunks of HTTP POST data and supports
  application/octet-stream, application/x-www-form-urlencoded, and
  multipart/form-data.

  Chunked bodies are supported by not passing a length value to new().

  It is currently used by the Catalyst manpage to parse POST bodies.


pkgId: 567fbdd7fc68ae1a76316ebd8313083f9de4dfdc8b1db232d9df67d2ae67c633
name: perl-HTTP-Cookies
arch: src
version: 6.01
epoch: 0
release: 4.1.1
summary: HTTP cookie jars
url: http://search.cpan.org/dist/HTTP-Cookies/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Cookies-6.01-4.1.1.src.rpm
checksum_type: sha256
description:
  This class is for objects that represent a "cookie jar" -- that is, a
  database of all the HTTP cookies that a given LWP::UserAgent object knows
  about.

  Cookies are a general mechanism which server side connections can use to
  both store and retrieve information on the client side of the connection.
  For more information about cookies refer to
  <URL:http://curl.haxx.se/rfc/cookie_spec.html> and
  <URL:http://www.cookiecentral.com/>. This module also implements the new
  style cookies described in _RFC 2965_. The two variants of cookies are
  supposed to be able to coexist happily.

  Instances of the class _HTTP::Cookies_ are able to store a collection of
  Set-Cookie2: and Set-Cookie: headers and are able to use this information
  to initialize Cookie-headers in _HTTP::Request_ objects. The state of a
  _HTTP::Cookies_ object can be saved in and restored from files.


pkgId: 182606d76947e1dccde05466e076202a1104c6cba1c3eee23f26f452d6eb690f
name: perl-HTTP-DAV
arch: src
version: 0.46
epoch: 0
release: 4.1.1
summary: WebDAV client library for Perl5
url: http://search.cpan.org/dist/HTTP-DAV/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-DAV-0.46-4.1.1.src.rpm
checksum_type: sha256
description:
  HTTP::DAV is a Perl API for interacting with and modifying content on
  webservers using the WebDAV protocol. Now you can LOCK, DELETE and PUT
  files and much more on a DAV-enabled webserver.


pkgId: 28997adaedbae5401727ae7a0f3d39416c0b7b485b0ff79764b4ac5514b916a2
name: perl-HTTP-Daemon
arch: src
version: 6.01
epoch: 0
release: 4.1.1
summary: a simple http server class
url: http://search.cpan.org/dist/HTTP-Daemon/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Daemon-6.01-4.1.1.src.rpm
checksum_type: sha256
description:
  Instances of the 'HTTP::Daemon' class are HTTP/1.1 servers that listen on a
  socket for incoming requests. The 'HTTP::Daemon' is a subclass of
  'IO::Socket::INET', so you can perform socket operations directly on it
  too.

  The accept() method will return when a connection from a client is
  available. The returned value will be an 'HTTP::Daemon::ClientConn' object
  which is another 'IO::Socket::INET' subclass. Calling the get_request()
  method on this object will read data from the client and return an
  'HTTP::Request' object. The ClientConn object also provide methods to send
  back various responses.


pkgId: a1dae75f99be912a94e51e703e299fcd0ad3ddf4139b3ef10df142d07b15abc6
name: perl-HTTP-Date
arch: src
version: 6.02
epoch: 0
release: 4.1.1
summary: Date conversion routines
url: http://search.cpan.org/dist/HTTP-Date/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Date-6.02-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides functions that deal the date formats used by the HTTP
  protocol (and then some more). Only the first two functions, time2str() and
  str2time(), are exported by default.


pkgId: 5cb22a40613439c6937624513a615628bc260e7494120fff31ebec09b502a30f
name: perl-HTTP-Lite
arch: src
version: 2.3
epoch: 0
release: 4.1.1
summary: Lightweight HTTP implementation
url: http://search.cpan.org/dist/HTTP-Lite
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Lite-2.3-4.1.1.src.rpm
checksum_type: sha256
description:
  HTTP::Lite is a stand-alone lightweight HTTP/1.1 implementation
  for perl.

  It is not intended as a replacement for the fully-features LWP module. Instead,
  it is intended for use in situations where it is desirable to install the
  minimal number of modules to achieve HTTP support, or where LWP is not a good
  candidate due to CPU overhead, such as slower processors.

  HTTP::Lite is also significantly faster than LWP.

  HTTP::Lite is ideal for CGI (or mod_perl) programs or for bundling for
  redistribution with larger packages where only HTTP GET and POST functionality
  are necessary.


pkgId: 9867eaae09136d26e0caf02339a3719541f55c9bcf1989a7599510f0e5ffc675
name: perl-HTTP-Message
arch: src
version: 6.02
epoch: 0
release: 8.1.1
summary: HTTP style message (base class)
url: http://search.cpan.org/dist/HTTP-Message/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Message-6.02-8.1.1.src.rpm
checksum_type: sha256
description:
  An 'HTTP::Message' object contains some headers and a content body. The
  following methods are available:

  * $mess = HTTP::Message->new

  * $mess = HTTP::Message->new( $headers )

  * $mess = HTTP::Message->new( $headers, $content )


pkgId: 8c66e55fd68055c6473f0732cf9967b49fcaac08294713bb65f4b6ad321d6dda
name: perl-HTTP-Negotiate
arch: src
version: 6.01
epoch: 0
release: 4.1.1
summary: choose a variant to serve
url: http://search.cpan.org/dist/HTTP-Negotiate/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Negotiate-6.01-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides a complete implementation of the HTTP content
  negotiation algorithm specified in _draft-ietf-http-v11-spec-00.ps_ chapter
  12. Content negotiation allows for the selection of a preferred content
  representation based upon attributes of the negotiable variants and the
  value of the various Accept* header fields in the request.

  The variants are ordered by preference by calling the function choose().

  The first parameter is reference to an array of the variants to choose
  among. Each element in this array is an array with the values [$id, $qs,
  $content_type, $content_encoding, $charset, $content_language,
  $content_length] whose meanings are described below. The $content_encoding
  and $content_language can be either a single scalar value or an array
  reference if there are several values.

  The second optional parameter is either a HTTP::Headers or a HTTP::Request
  object which is searched for "Accept*" headers. If this parameter is
  missing, then the accept specification is initialized from the CGI
  environment variables HTTP_ACCEPT, HTTP_ACCEPT_CHARSET,
  HTTP_ACCEPT_ENCODING and HTTP_ACCEPT_LANGUAGE.

  In an array context, choose() returns a list of [variant identifier,
  calculated quality, size] tuples. The values are sorted by quality, highest
  quality first. If the calculated quality is the same for two variants, then
  they are sorted by size (smallest first). _E.g._:

    (['var1', 1, 2000], ['var2', 0.3, 512], ['var3', 0.3, 1024]);

  Note that also zero quality variants are included in the return list even
  if these should never be served to the client.

  In a scalar context, it returns the identifier of the variant with the
  highest score or 'undef' if none have non-zero quality.

  If the $HTTP::Negotiate::DEBUG variable is set to TRUE, then a lot of noise
  is generated on STDOUT during evaluation of choose().


pkgId: 626cb16b33c9241dd0798acc80ff763d3462d4c4a1a5cbfa442b2b3372cd43ad
name: perl-HTTP-Server-Simple
arch: src
version: 0.44
epoch: 0
release: 5.1.1
summary: Lightweight HTTP server
url: http://search.cpan.org/perldoc?HTTP::Server::Simple
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTP-Server-Simple-0.44-5.1.1.src.rpm
checksum_type: sha256
description:
  This is a simple standalone HTTP server. By default, it doesn't thread or fork.
  It does, however, act as a simple frontend which can be used to build a
  standalone web-based application or turn a CGI into one.

  It is possible to use Net::Server classes to create forking, pre-forking, and
  other types of more complicated servers; see "net_server".

  Author:
  -------
      Jesse Vincent, <jesse@bestpractical.com>


pkgId: c253e408c75686045bdbc278cfd75a431c06600143c7cc33b9cedccc79c8b264
name: perl-HTTPS-Daemon
arch: src
version: 1.04
epoch: 0
release: 65.1.1
summary: a simple http server class with SSL support
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-HTTPS-Daemon-1.04-65.1.1.src.rpm
checksum_type: sha256
description:
  HTTP::Daemon::SSL is a descendant of HTTP::Daemon that uses SSL sockets
  (via IO::Socket::SSL) instead of cleartext sockets.  It also handles
  SSL-specific problems, such as dealing with HTTP clients that attempt
  to connect to it without using SSL.


pkgId: 7e7b27bfadbb0394565365e4d441e0aecc6520054cf4a3b6284fffb0d0397f61
name: perl-Hash-Merge
arch: src
version: 0.12
epoch: 0
release: 4.1.1
summary: Merges arbitrarily deep hashes into a single hash
url: http://search.cpan.org/dist/Hash-Merge/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Hash-Merge-0.12-4.1.1.src.rpm
checksum_type: sha256
description:
  Hash::Merge merges two arbitrarily deep hashes into a single hash. That is,
  at any level, it will add non-conflicting key-value pairs from one hash to
  the other, and follows a set of specific rules when there are key value
  conflicts (as outlined below). The hash is followed recursively, so that
  deeply nested hashes that are at the same level will be merged when the
  parent hashes are merged. *Please note that self-referencing hashes, or
  recursive references, are not handled well by this method.*

  Values in hashes are considered to be either ARRAY references, HASH
  references, or otherwise are treated as SCALARs. By default, the data
  passed to the merge function will be cloned using the Clone module;
  however, if necessary, this behavior can be changed to use as many of the
  original values as possible. (See 'set_clone_behavior').

  Because there are a number of possible ways that one may want to merge
  values when keys are conflicting, Hash::Merge provides several preset
  methods for your convenience, as well as a way to define you own.


pkgId: 7ea02eea0855b14cbba4200a557f5d3a9740ae255ee1bec0d92b421d925c939e
name: perl-Hash-Merge-Simple
arch: src
version: 0.051
epoch: 0
release: 4.1.1
summary: Recursively merge two or more hashes, simply
url: http://search.cpan.org/dist/Hash-Merge-Simple/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Hash-Merge-Simple-0.051-4.1.1.src.rpm
checksum_type: sha256
description:
  Hash::Merge::Simple will recursively merge two or more hashes and return
  the result as a new hash reference. The merge function will descend and
  merge hashes that exist under the same node in both the left and right
  hash, but doesn't attempt to combine arrays, objects, scalars, or anything
  else. The rightmost hash also takes precedence, replacing whatever was in
  the left hash if a conflict occurs.

  This code was pretty much taken straight from the Catalyst::Utils manpage,
  and modified to handle more than 2 hashes at the same time.


pkgId: fcf23ec81df61c9ef18c66de9f5f08d6e20771358fc8093ea6cd5e5e869a4882
name: perl-Hash-MoreUtils
arch: src
version: 0.02
epoch: 0
release: 8.1.1
summary: Provide the stuff missing in Hash::Util
url: http://search.cpan.org/dist/Hash-MoreUtils
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Hash-MoreUtils-0.02-8.1.1.src.rpm
checksum_type: sha256
description:
  Similar to "List::MoreUtils", "Hash::MoreUtils" contains trivial but
  commonly-used functionality for hashes.


pkgId: c89592603b6a0263402cde9af5f89d79b0d6ae7a25a3caa99a5d8ad5948323f8
name: perl-Hash-MultiValue
arch: src
version: 0.12
epoch: 0
release: 4.1.1
summary: Store multiple values per key
url: http://search.cpan.org/dist/Hash-MultiValue/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Hash-MultiValue-0.12-4.1.1.src.rpm
checksum_type: sha256
description:
  Hash::MultiValue is an object (and a plain hash reference) that may contain
  multiple values per key, inspired by MultiDict of WebOb.


pkgId: e9adebe181e8a466f1b90039259e5e114a3ad7fc6e6786446c6be218aeffba8b
name: perl-Hash-Util-FieldHash-Compat
arch: src
version: 0.03
epoch: 0
release: 8.1.1
summary: Use L<Hash::Util::FieldHash> or ties, depending
url: http://search.cpan.org/dist/Hash-Util-FieldHash-Compat/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Hash-Util-FieldHash-Compat-0.03-8.1.1.src.rpm
checksum_type: sha256
description:
  Under older perls this module provides a drop in compatible api to the
  Hash::Util::FieldHash manpage using the perltie manpage. When the
  Hash::Util::FieldHash manpage is available it will use that instead.

  This way code requiring field hashes can benefit from fast, robust field
  hashes on Perl 5.10 and newer, but still run on older perls that don't ship
  with that module.

  See the Hash::Util::FieldHash manpage for all the details of the API.


pkgId: 849900bdcf8812fbb3840dd458d1cad0c4312f067be1bc203dee93658e597366
name: perl-Hook-LexWrap
arch: src
version: 0.24
epoch: 0
release: 12.1.1
summary: Lexically scoped subroutine wrappers
url: http://search.cpan.org/dist/Hook-LexWrap/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Hook-LexWrap-0.24-12.1.1.src.rpm
checksum_type: sha256
description:
  Hook::LexWrap allows you to install a pre- or post-wrapper (or both) around
  an existing subroutine. Unlike other modules that provide this capacity
  (e.g. Hook::PreAndPost and Hook::WrapSub), Hook::LexWrap implements
  wrappers in such a way that the standard caller function works correctly
  within the wrapped subroutine.

  Authors:
  --------
      Damian Conway (damian@conway.org)


pkgId: 1edb4cacd4893a4490ab798c84b129f4c3e8a7c3449f54849aca3f6d76677906
name: perl-IO-All
arch: src
version: 0.44
epoch: 0
release: 4.1.1
summary: IO::All of it to Graham and Damian!
url: http://search.cpan.org/dist/IO-All
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-All-0.44-4.1.1.src.rpm
checksum_type: sha256
description:
  IO::All combines all of the best Perl IO modules into a single nifty
  object oriented interface to greatly simplify your everyday Perl IO
  idioms. It exports a single function called "io", which returns a new
  IO::All object. And that object can do it all!


pkgId: 0a1ad45d342597bdf5b8fc3ca9c14455d9fb3b0b1f990786c1542058934e176f
name: perl-IO-Digest
arch: src
version: 0.10
epoch: 0
release: 158.1.1
summary: Calculate digests while reading or writing
url: http://search.cpan.org/dist/IO-Digest/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Digest-0.10-158.1.1.src.rpm
checksum_type: sha256
description:
  This module allows you to calculate digests while reading or writing file
  handles. This avoids the case you need to reread the same content to
  compute the digests after written a file.


pkgId: ef34c427fb67bd856ea49902217c24c67d93551e74d467e614be3a45e1d1740c
name: perl-IO-Interactive
arch: src
version: 0.0.6
epoch: 0
release: 9.1.1
summary: Utilities for interactive I/O
url: http://search.cpan.org/dist/IO-Interactive/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Interactive-0.0.6-9.1.1.src.rpm
checksum_type: sha256
description:
  This module provides three utility subroutines that make it easier to
  develop interactive applications...

  * 'is_interactive()'

    This subroutine returns true if '*ARGV' and the currently selected
    filehandle (usually '*STDOUT') are connected to the terminal. The test is
    considerably more sophisticated than:

        -t *ARGV && -t *STDOUT

    as it takes into account the magic behaviour of '*ARGV'.

    You can also pass 'is_interactive' a writable filehandle, in which case
    it requires that filehandle be connected to a terminal (instead of the
    currently selected). The usual suspect here is '*STDERR':

        if ( is_interactive(*STDERR) ) {
            carp $warning;
        }

  * 'interactive()'

    This subroutine returns '*STDOUT' if 'is_interactive' is true. If
    'is_interactive()' is false, 'interactive' returns a filehandle that does
    not print.

    This makes it easy to create applications that print out only when the
    application is interactive:

        print {interactive} "Please enter a value: ";
        my $value = <>;

    You can also pass 'interactive' a writable filehandle, in which case it
    writes to that filehandle if it is connected to a terminal (instead of
    writinbg to '*STDOUT'). Once again, the usual suspect is '*STDERR':

        print {interactive(*STDERR)} $warning;

  * 'busy {...}'

    This subroutine takes a block as its single argument and executes that
    block. Whilst the block is executed, '*ARGV' is temporarily replaced by a
    closed filehandle. That is, no input from '*ARGV' is possible in a 'busy'
    block. Furthermore, any attempts to send input into the 'busy' block
    through '*ARGV' is intercepted and a warning message is printed to
    '*STDERR'. The 'busy' call returns a filehandle that contains the
    intercepted input.

    A 'busy' block is therefore useful to prevent attempts at input when the
    program is busy at some non-interactive task.


pkgId: e6cd0b45a6d41f800a39fb542d1bffc2c422457f6540ddec74a07b584d61b4f8
name: perl-IO-Interface
arch: src
version: 1.06
epoch: 0
release: 6.1.1
summary: Perl extension for access to network card configuration information
url: http://search.cpan.org/dist/IO-Interface/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Interface-1.06-6.1.1.src.rpm
checksum_type: sha256
description:
  IO::Interface adds methods to IO::Socket objects that allows them to be
     used to retrieve and change information about the network interfaces on
     your system. In addition to the object-oriented access methods, you can
     use a function-oriented style.


pkgId: f7114387346dfa344c2ecb69ac80a92d1d9d298429dc781e274518220bf95821
name: perl-IO-Multiplex
arch: src
version: 1.13
epoch: 0
release: 8.1.1
summary: Manage IO on many file handles
url: http://cpan.org/modules/by-module/IO/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Multiplex-1.13-8.1.1.src.rpm
checksum_type: sha256
description:
  "IO::Multiplex" reduces the effort of managing multiple file handles.
  It is a fancy front end to the "select" system call.


pkgId: 6c3ab72759004f27dbca3b966f97a875876a504a6a2aab96132a9f0f8e931b4a
name: perl-IO-Pager
arch: src
version: 0.24
epoch: 0
release: 4.1.1
summary: Select a pager and pipe text to it if destination is a TTY
url: http://search.cpan.org/dist/IO-Pager/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Pager-0.24-4.1.1.src.rpm
checksum_type: sha256
description:
  IO::Pager can be used to locate an available pager and set the _PAGER_
  environment variable (see the /NOTES manpage). It is also a factory for
  creating I/O objects such as the IO::Pager::Buffered manpage and the
  IO::Pager::Unbuffered manpage.

  IO::Pager subclasses are designed to programmatically decide whether or not
  to pipe a filehandle's output to a program specified in _PAGER_. Subclasses
  may implement only the IO handle methods desired and inherit the remainder
  of those outlined below from IO::Pager. For anything else, YMMV. See the
  appropriate subclass for implementation specific details.


pkgId: 2be640296ee0f8e0fdaf35d9ca93acc3ba081f7960bce5f530affa9d966483b3
name: perl-IO-Socket-INET6
arch: src
version: 2.69
epoch: 0
release: 5.1.1
summary: Object interface for AF_INET|AF_INET6 domain sockets
url: http://search.cpan.org/dist/IO-Socket-INET6/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Socket-INET6-2.69-5.1.1.src.rpm
checksum_type: sha256
description:
  IO::Socket::INET6 provides an object interface to creating and using
     sockets in either AF_INET or AF_INET6 domains. It is built upon the
     IO::Socket interface and inherits all the methods defined by IO::Socket.


pkgId: 029bd79e4358560f3ad4bfad2184164a15aae9a7fef6e35ebc26736d8aab47de
name: perl-IO-Socket-Multicast
arch: src
version: 1.12
epoch: 0
release: 13.1.1
summary: Send and receive multicast messages
url: http://search.cpan.org/dist/IO-Socket-Multicast
rpm_license: Artistic-1.0 ; GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Socket-Multicast-1.12-13.1.1.src.rpm
checksum_type: sha256
description:
  The IO::Socket::Multicast module subclasses IO::Socket::INET to enable
  you to manipulate multicast groups. With this module (and an operating
  system that supports multicasting), you will be able to receive
  incoming multicast transmissions and generate your own outgoing
  multicast packets.



  Authors:
  --------
      Lincoln Stein <lstein@cshl.org>


pkgId: fae07882643f7d11d4cfb1ca65ce5632e61151111d07cb11c3bf247ebc832913
name: perl-IO-Socket-SSL
arch: src
version: 1.55
epoch: 0
release: 4.1.1
summary: Nearly transparent SSL encapsulation for IO::Socket::INET
url: http://search.cpan.org/dist/IO-Socket-SSL/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Socket-SSL-1.55-4.1.1.src.rpm
checksum_type: sha256
description:
  This module is a true drop-in replacement for IO::Socket::INET that uses
  SSL to encrypt data before it is transferred to a remote server or client.
  IO::Socket::SSL supports all the extra features that one needs to write a
  full-featured SSL client or server application: multiple SSL contexts,
  cipher selection, certificate verification, and SSL version selection. As
  an extra bonus, it works perfectly with mod_perl.

  If you have never used SSL before, you should read the appendix labelled
  'Using SSL' before attempting to use this module.

  If you have used this module before, read on, as versions 0.93 and above
  have several changes from the previous IO::Socket::SSL versions (especially
  see the note about return values).

  If you are using non-blocking sockets read on, as version 0.98 added better
  support for non-blocking.

  If you are trying to use it with threads see the BUGS section.


pkgId: e8c58282cbcb4e14881a38439772a2fd7535cbcb322d937305c7e3f8ec9f8413
name: perl-IO-String
arch: src
version: 1.08
epoch: 0
release: 160.1.1
summary: Perl IO/String interface
url: http://search.cpan.org/~gaas/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-String-1.08-160.1.1.src.rpm
checksum_type: sha256
description:
  IO::String is an IO::File (and IO::Handle) compatible class that reads
  or writes data from in-core strings.



  Authors:
  --------
      Gisle Aas.  <gisle@aas.no>


pkgId: 45cbccb5dc0bab5eac54ef6e1c2ace7d90b4bd3f57115022b80fbcae9ee667f9
name: perl-IO-Stty
arch: src
version: 0.03
epoch: 0
release: 12.1.1
summary: IO::Stty Perl module
url: http://search.cpan.org/dist/IO-Stty/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Stty-0.03-12.1.1.src.rpm
checksum_type: sha256
description:
  This is the PERL POSIX compliant stty.

  Authors:
  --------
      Austin Schutz <auschutz@cpan.org>
      Todd Rinaldo <toddr@cpan.org>


pkgId: d7c26a24b73ea7a6d0ae7420bf96fc4697ae6f723f3b398421ed48417b35919e
name: perl-IO-Tty
arch: src
version: 1.10
epoch: 0
release: 8.1.1
summary: Low-level allocate a pseudo-Tty, import constants.
url: http://search.cpan.org/dist/IO-Tty/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IO-Tty-1.10-8.1.1.src.rpm
checksum_type: sha256
description:
  'IO::Tty' is used internally by 'IO::Pty' to create a pseudo-tty. You
  wouldn't want to use it directly except to import constants, use 'IO::Pty'.
  For a list of importable constants, see the IO::Tty::Constant manpage.

  Windows is now supported, but ONLY under the Cygwin environment, see the
  http://sources.redhat.com/cygwin/ manpage.

  Please note that pty creation is very system-dependend. From my experience,
  any modern POSIX system should be fine. Find below a list of systems that
  'IO::Tty' should work on. A more detailed table (which is slowly getting
  out-of-date) is available from the project pages document manager at
  SourceForge the http://sourceforge.net/projects/expectperl/ manpage.

  If you have problems on your system and your system is listed in the
  "verified" list, you probably have some non-standard setup, e.g. you
  compiled your Linux-kernel yourself and disabled ptys (bummer!). Please ask
  your friendly sysadmin for help.

  If your system is not listed, unpack the latest version of 'IO::Tty', do a
  ''perl Makefile.PL; make; make test; uname -a'' and send me
  (_RGiersig@cpan.org_) the results and I'll see what I can deduce from that.
  There are chances that it will work right out-of-the-box...

  If it's working on your system, please send me a short note with details
  (version number, distribution, etc. 'uname -a' and 'perl -V' is a good
  start; also, the output from "perl Makefile.PL" contains a lot of
  interesting info, so please include that as well) so I can get an overview.
  Thanks!


pkgId: 223c1f944531a88cf4b450f26b67bdadf95cb3925f5ab89d7df473e0fdaf35de
name: perl-IP-Country
arch: src
version: 2.27
epoch: 0
release: 17.1.1
summary: Fast lookup of country codes from IP addresses
url: http://search.cpan.org/dist/IP-Country
rpm_license: (GPL-1.0+ or Artistic-1.0) and SUSE-Redistributable-Content
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IP-Country-2.27-17.1.1.src.rpm
checksum_type: sha256
description:
  Finding the home country of a client using only the IP address can be
  difficult. Looking up the domain name associated with that address can provide
  some help, but many IP addresses are not reverse mapped to any useful domain, and
  the most common domain (.com) offers no help when looking for country.

  This module comes bundled with a database of countries where various IP
  addresses have been assigned. Although the country of assignment will probably
  be the country associated with a large ISP rather than the client herself, this
  is probably good enough for most log analysis applications, and under test has
  proved to be as accurate as reverse-DNS and WHOIS lookup.

  Authors:
  --------
      Nigel Wetters Gourlay


pkgId: 1218c22bdf5f3f70a3cebb3eb19ebbbe69428012fac3cba6cd4883baea5c88a4
name: perl-IPC-Run
arch: src
version: 0.91
epoch: 0
release: 5.1.1
summary: System() and Background Procs with Piping, Redirs, and PTYs
url: http://cpan.org/modules/by-module/IPC/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IPC-Run-0.91-5.1.1.src.rpm
checksum_type: sha256
description:
  IPC::Run allows you run and interact with child processes using files,
  pipes, and pseudo-ttys.  Both system()-style and scripted usages are
  supported and may be mixed. Like-wise, functional and OO API styles are
  both supported and may be mixed.


pkgId: 8c1282f91b8044e83cf9e3c2a7c7dc2ad6c3c4332d662a3d7757d56b0b330f39
name: perl-IPC-Run3
arch: src
version: 0.045
epoch: 0
release: 4.1.1
summary: Run a subprocess with input/ouput redirection
url: http://search.cpan.org/dist/IPC-Run3/
rpm_license: BSD-2-Clause or GPL-2.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IPC-Run3-0.045-4.1.1.src.rpm
checksum_type: sha256
description:
  This module allows you to run a subprocess and redirect stdin, stdout,
  and/or stderr to files and perl data structures. It aims to satisfy 99% of
  the need for using 'system', 'qx', and 'open3' with a simple, extremely
  Perlish API.

  Speed, simplicity, and portability are paramount. (That's speed of Perl
  code; which is often much slower than the kind of buffered I/O that this
  module uses to spool input to and output from the child command.)


pkgId: b54987536e54ec2adbf59e271d31a03d08c70931c47fccf1eda25c35b618c402
name: perl-IPC-System-Simple
arch: src
version: 1.21
epoch: 0
release: 2.1.1
summary: Run commands simply, with detailed diagnostics
url: http://search.cpan.org/dist/IPC-System-Simple
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-IPC-System-Simple-1.21-2.1.1.src.rpm
checksum_type: sha256
description:
  Calling Perl's in-built "system()" function is easy, determining if it was
  successful is *hard*. Let's face it, $? isn't the nicest variable in the
  world to play with, and even if you *do* check it, producing a
  well-formatted error string takes a lot of work.
  "IPC::System::Simple" takes the hard work out of calling external
  commands.


pkgId: 23e8e1957f3fa252733b5cd6288e78abfc1802740127a6827593216776a4cb19
name: perl-Image-ExifTool
arch: src
version: 9.01
epoch: 0
release: 3.1.1
summary: Perl module to read and write meta information
url: http://search.cpan.org/dist/Image-ExifTool/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Image-ExifTool-9.01-3.1.1.src.rpm
checksum_type: sha256
description:
  ExifTool by Phil Harvey (phil at owl.phy.queensu.ca)
  ----------------------------------------------------------------------------

  ExifTool is a customizable set of Perl modules plus a full-featured
  application for reading and writing meta information in a wide variety of
  files, including the maker note information of many digital cameras by
  various manufacturers such as Canon, Casio, FujiFilm, GE, HP, JVC/Victor,
  Kodak, Leaf, Minolta/Konica-Minolta, Nikon, Olympus/Epson, Panasonic/Leica,
  Pentax/Asahi, Reconyx, Ricoh, Samsung, Sanyo, Sigma/Foveon and Sony.

  Below is a list of file types and meta information formats currently
  supported by ExifTool (r = read, w = write, c = create):

    File Types
    ------------+-------------+-------------+-------------+------------
    3FR   r     | DVB   r     | M4A/V r     | PBM   r/w   | RWZ   r
    3G2   r     | DYLIB r     | MEF   r/w   | PDF   r/w   | RM    r
    3GP   r     | EIP   r     | MIE   r/w/c | PEF   r/w   | SO    r
    ACR   r     | EPS   r/w   | MIFF  r     | PFA   r     | SR2   r/w
    AFM   r     | ERF   r/w   | MKA   r     | PFB   r     | SRF   r
    AI    r/w   | EXE   r     | MKS   r     | PFM   r     | SRW   r/w
    AIFF  r     | EXIF  r/w/c | MKV   r     | PGF   r     | SVG   r
    APE   r     | F4A/V r     | MNG   r/w   | PGM   r/w   | SWF   r
    ARW   r/w   | FLA   r     | MOS   r/w   | PICT  r     | THM   r/w
    ASF   r     | FLAC  r     | MOV   r     | PMP   r     | TIFF  r/w
    AVI   r     | FLV   r     | MP3   r     | PNG   r/w   | TTC   r
    BMP   r     | FPX   r     | MP4   r     | PPM   r/w   | TTF   r
    BTF   r     | GIF   r/w   | MPC   r     | PPT   r     | VRD   r/w/c
    CHM   r     | GZ    r     | MPG   r     | PPTX  r     | VSD   r
    COS   r     | HDP   r/w   | MPO   r/w   | PS    r/w   | WAV   r
    CR2   r/w   | HTML  r     | MQV   r     | PSB   r/w   | WDP   r/w
    CRW   r/w   | ICC   r/w/c | MRW   r/w   | PSD   r/w   | WEBP  r
    CS1   r/w   | IIQ   r/w   | MXF   r     | PSP   r     | WEBM  r
    DCM   r     | IND   r/w   | NEF   r/w   | QTIF  r     | WMA   r
    DCP   r/w   | ITC   r     | NRW   r/w   | RA    r     | WMV   r
    DCR   r     | J2C   r     | NUMBERS r   | RAF   r/w   | X3F   r/w
    DFONT r     | JNG   r/w   | ODP   r     | RAM   r     | XCF   r
    DIVX  r     | JP2   r/w   | ODS   r     | RAR   r     | XLS   r
    DJVU  r     | JPEG  r/w   | ODT   r     | RAW   r/w   | XLSX  r
    DLL   r     | K25   r     | OGG   r     | RIFF  r     | XMP   r/w/c
    DNG   r/w   | KDC   r     | OGV   r     | RSRC  r     | ZIP   r
    DOC   r     | KEY   r     | ORF   r/w   | RTF   r     |
    DOCX  r     | LNK   r     | OTF   r     | RW2   r/w   |
    DV    r     | M2TS  r     | PAGES r     | RWL   r/w   |

    Meta Information
    ----------------------+----------------------+---------------------
    EXIF           r/w/c  |  CIFF           r/w  |  Ricoh RMETA    r
    GPS            r/w/c  |  AFCP           r/w  |  Picture Info   r
    IPTC           r/w/c  |  Kodak Meta     r/w  |  Adobe APP14    r
    XMP            r/w/c  |  FotoStation    r/w  |  MPF            r
    MakerNotes     r/w/c  |  PhotoMechanic  r/w  |  Stim           r
    Photoshop IRB  r/w/c  |  JPEG 2000      r    |  APE            r
    ICC Profile    r/w/c  |  DICOM          r    |  Vorbis         r
    MIE            r/w/c  |  Flash          r    |  SPIFF          r
    JFIF           r/w/c  |  FlashPix       r    |  DjVu           r
    Ducky APP12    r/w/c  |  QuickTime      r    |  M2TS           r
    PDF            r/w/c  |  Matroska       r    |  PE/COFF        r
    PNG            r/w/c  |  GeoTIFF        r    |  AVCHD          r
    Canon VRD      r/w/c  |  PrintIM        r    |  ZIP            r
    Nikon Capture  r/w/c  |  ID3            r    |  (and more)

  See html/index.html for more details about ExifTool features.


pkgId: dfcc56e4501e2c7360f2e60aeb0dc5ef1830ee9a423302256b99f9ed19379d13
name: perl-Image-Size
arch: src
version: 3.230
epoch: 0
release: 15.1.1
summary: A Perl Module to deal with Dimensions of an Image in Several Popular Formats
url: http://search.cpan.org/perldoc?Image::Size
rpm_license: LGPL-2.1 or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Image-Size-3.230-15.1.1.src.rpm
checksum_type: sha256
description:
  The Image::Size library is based upon the "wwwis" script written by
  Alex Knowles *(alex@ed.ac.uk)*, a tool to examine HTML and add 'width'
  and 'height' parameters to image tags. The sizes are cached internally
  based on the file name, so multiple calls on the same file name (images
  used in bulleted lists, for example) do not result in repeated
  computations.



  Authors:
  --------
      Randy J. Ray <rjray@blackperl.com>
      Alex Knowles <alex@ed.ac.uk>
      Andrew Tong <werdna@ugcs.caltech.edu>
      and others


pkgId: aecd7e4b84cff97a0e9ff241ac4468ea6d5439bc4932e93600e1a16504e4280a
name: perl-Inline
arch: src
version: 0.50
epoch: 0
release: 5.1.1
summary: Write Perl subroutines in other programming languages
url: http://www.cpan.org/modules/by-module/Inline/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Inline-0.50-5.1.1.src.rpm
checksum_type: sha256
description:
  Inline lets you write Perl subroutines in other programming languages,
  like C, C++, Java, Python, Tcl and even Assembly. You don't need to
  compile anything. All the details are handled transparently, so you can
  just run your Perl script like normal.


pkgId: c689071eccb6f2485b93df726de67d53755b6f436d5099fe8ea6511024c39244
name: perl-Iterator
arch: src
version: 0.03
epoch: 0
release: 9.1.1
summary: A general-purpose iterator class
url: http://search.cpan.org/dist/Iterator/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Iterator-0.03-9.1.1.src.rpm
checksum_type: sha256
description:
  This module is meant to be the definitive implementation of iterators, as
  popularized by Mark Jason Dominus's lectures and recent book (_Higher Order
  Perl_, Morgan Kauffman, 2005).

  An "iterator" is an object, represented as a code block that generates the
  "next value" of a sequence, and generally implemented as a closure. When
  you need a value to operate on, you pull it from the iterator. If it
  depends on other iterators, it pulls values from them when it needs to.
  Iterators can be chained together (see the Iterator::Util manpage for
  functions that help you do just that), queueing up work to be done but _not
  actually doing it_ until a value is needed at the front end of the chain.
  At that time, one data value is pulled through the chain.

  Contrast this with ordinary array processing, where you load or compute all
  of the input values at once, then loop over them in memory. It's analogous
  to the difference between looping over a file one line at a time, and
  reading the entire file into an array of lines before operating on it.

  Iterator.pm provides a class that simplifies creation and use of these
  iterator objects. Other 'Iterator::' modules (see the /"SEE ALSO" manpage)
  provide many general-purpose and special-purpose iterator functions.

  Some iterators are infinite (that is, they generate infinite sequences),
  and some are finite. When the end of a finite sequence is reached, the
  iterator code block should throw an exception of the type
  'Iterator::X::Am_Now_Exhausted'; this is usually done via the the /is_done
  manpage function.. This will signal the Iterator class to mark the object
  as exhausted. The the /is_exhausted manpage method will then return true,
  and the the /isnt_exhausted manpage method will return false. Any further
  calls to the the /value manpage method will throw an exception of the type
  'Iterator::X::Exhausted'. See the /DIAGNOSTICS manpage.

  Note that in many, many cases, you will not need to explicitly create an
  iterator; there are plenty of iterator generation and manipulation
  functions in the other associated modules. You can just plug them together
  like building blocks.


pkgId: 6f4e7f99613fc3ebd32dda10a0b4ac96a0caff56724dc03859de0bd8d2e50281
name: perl-Iterator-Util
arch: src
version: 0.02
epoch: 0
release: 9.1.1
summary: Essential utilities for the Iterator class
url: http://search.cpan.org/dist/Iterator-Util/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Iterator-Util-0.02-9.1.1.src.rpm
checksum_type: sha256
description:
  This module implements many useful functions for creating and manipulating
  iterator objects.

  An "iterator" is an object, represented as a code block that generates the
  "next value" of a sequence, and generally implemented as a closure. For
  further information, including a tutorial on using iterator objects, see
  the the Iterator manpage documentation.


pkgId: c8caa7889989a22bd52f0f80ae716758c15e7af23b6408736b4a1d32548644d5
name: perl-JSON
arch: src
version: 2.53
epoch: 0
release: 8.1.1
summary: JSON (JavaScript Object Notation) encoder/decoder
url: http://search.cpan.org/dist/JSON/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-JSON-2.53-8.1.1.src.rpm
checksum_type: sha256
description:
   ************************** CAUTION ********************************
   * This is 'JSON module version 2' and there are many differences  *
   * to version 1.xx                                                 *
   * Please check your applications useing old version.              *
   *   See to 'INCOMPATIBLE CHANGES TO OLD VERSION'                  *
   *******************************************************************

  JSON (JavaScript Object Notation) is a simple data format. See to the
  http://www.json.org/ manpage and 'RFC4627'(the
  http://www.ietf.org/rfc/rfc4627.txt manpage).

  This module converts Perl data structures to JSON and vice versa using
  either the JSON::XS manpage or the JSON::PP manpage.

  JSON::XS is the fastest and most proper JSON module on CPAN which must be
  compiled and installed in your environment. JSON::PP is a pure-Perl module
  which is bundled in this distribution and has a strong compatibility to
  JSON::XS.

  This module try to use JSON::XS by default and fail to it, use JSON::PP
  instead. So its features completely depend on JSON::XS or JSON::PP.

  See to the BACKEND MODULE DECISION manpage.

  To distinguish the module name 'JSON' and the format type JSON, the former
  is quoted by C<> (its results vary with your using media), and the latter
  is left just as it is.

  Module name : 'JSON'

  Format type : JSON


pkgId: 4245a361111affb5d0e9e48a018d5f479cb345d1013fc3ac22125983edf23340
name: perl-JSON-Any
arch: src
version: 1.29
epoch: 0
release: 8.1.1
summary: Wrapper Class for the various JSON classes
url: http://search.cpan.org/dist/JSON-Any/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-JSON-Any-1.29-8.1.1.src.rpm
checksum_type: sha256
description:
  Wrapper Class for the various JSON classes.

  This module will provide a coherent API to bring together the various JSON
  modules currently on CPAN. This module will allow you to code to any JSON API
  and have it work regardless of which JSON module is actually installed.


pkgId: ae0563190c46b8bc4c40e512e56688f9e4048562e3594ace95789e9979406431
name: perl-JSON-DWIW
arch: src
version: 0.47
epoch: 0
release: 8.1.1
summary: JSON converter that Does What I Want
url: http://search.cpan.org/dist/JSON-DWIW/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-JSON-DWIW-0.47-8.1.1.src.rpm
checksum_type: sha256
description:
  Other JSON modules require setting several parameters before calling the
  conversion methods to do what I want. This module does things by default
  that I think should be done when working with JSON in Perl. This module
  also encodes and decodes faster than the JSON manpage.pm and the JSON::Syck
  manpage in my benchmarks.

  This means that any piece of data in Perl (assuming it's valid unicode)
  will get converted to something in JSON instead of throwing an exception.
  It also means that output will be strict JSON, while accepted input will be
  flexible, without having to set any options.

  For a list of changes in recent versions, see the documentation for the
  JSON::DWIW::Changes manpage.

  This module can be downloaded from the
  http://www.cpan.org/authors/id/D/DO/DOWENS/ manpage.


pkgId: e7739d1e2c14db0efa3df38c6417d81850b26471a5bbdf1910f8212134690546
name: perl-JSON-RPC
arch: src
version: 0.96
epoch: 0
release: 15.1.1
summary: Perl implementation of JSON-RPC 1.1 protocol
url: http://search.cpan.org/dist/JSON-RPC/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-JSON-RPC-0.96-15.1.1.src.rpm
checksum_type: sha256
description:
  JSON-RPC is a stateless and light-weight remote procedure call (RPC)
  protocol for inter-networking applications over HTTP. It uses JSON as the
  data format for of all facets of a remote procedure call, including all
  application data carried in parameters.

  The old modules - JSONRPC::Transport::HTTP and Apache::JSONRPC are deprecated.
  Please try to use JSON::RPC::Server and JSON::RPC::Client which support both
  JSON-RPC protocol version 1.1 and 1.0.

  Authors:
  --------
      Makamaka Hannyaharamitu, <makamaka[at]cpan.org>


pkgId: 3f09c133fc8621ddb0c137fc691c5f5c30b6fb4f47f1a18eeda3b2ec9206d574
name: perl-JSON-XS
arch: src
version: 2.32
epoch: 0
release: 8.1.1
summary: JSON serialising/deserialising, done correctly and fast
url: http://search.cpan.org/dist/JSON-XS/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-JSON-XS-2.32-8.1.1.src.rpm
checksum_type: sha256
description:
  This module converts Perl data structures to JSON and vice versa. Its
  primary goal is to be *correct* and its secondary goal is to be *fast*.
  To reach the latter goal it was written in C.

  Beginning with version 2.0 of the JSON module, when both JSON and
  JSON::XS are installed, then JSON will fall back on JSON::XS (this can
  be overridden) with no overhead due to emulation (by inheriting
  constructor and methods). If JSON::XS is not available, it will fall
  back to the compatible JSON::PP module as backend, so using JSON instead
  of JSON::XS gives you a portable JSON API that can be fast when you need
  and doesn`t require a C compiler when that is a problem.

  As this is the n-th-something JSON module on CPAN, what was the reason
  to write yet another JSON module? While it seems there are many JSON
  modules, none of them correctly handle all corner cases, and in most
  cases their maintainers are unresponsive, gone missing, or not listening
  to bug reports for other reasons.

  Author:
  -------
      Marc Lehmann <schmorp@schmorp.de>


pkgId: e820d9743a25476d1eb9c3b05472d20d3da2f6787750a8da722a17ce1290a925
name: perl-LWP-MediaTypes
arch: src
version: 6.02
epoch: 0
release: 4.1.1
summary: guess media type for a file or a URL
url: http://search.cpan.org/dist/LWP-MediaTypes/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-LWP-MediaTypes-6.02-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides functions for handling media (also known as MIME)
  types and encodings. The mapping from file extensions to media types is
  defined by the _media.types_ file. If the _~/.media.types_ file exists it
  is used instead. For backwards compatibility we will also look for
  _~/.mime.types_.

  The following functions are exported by default:

  * guess_media_type( $filename )

  * guess_media_type( $uri )

  * guess_media_type( $filename_or_uri, $header_to_modify )

    This function tries to guess media type and encoding for a file or a URI.
    It returns the content type, which is a string like '"text/html"'. In
    array context it also returns any content encodings applied (in the order
    used to encode the file). You can pass a URI object reference, instead of
    the file name.

    If the type can not be deduced from looking at the file name, then
    guess_media_type() will let the '-T' Perl operator take a look. If this
    works (and '-T' returns a TRUE value) then we return _text/plain_ as the
    type, otherwise we return _application/octet-stream_ as the type.

    The optional second argument should be a reference to a HTTP::Headers
    object or any object that implements the $obj->header method in a similar
    way. When it is present the values of the 'Content-Type' and
    'Content-Encoding' will be set for this header.

  * media_suffix( $type, ... )

    This function will return all suffixes that can be used to denote the
    specified media type(s). Wildcard types can be used. In a scalar context
    it will return the first suffix found. Examples:

      @suffixes = media_suffix('image/*', 'audio/basic');
      $suffix = media_suffix('text/html');

  The following functions are only exported by explicit request:

  * add_type( $type, @exts )

    Associate a list of file extensions with the given media type. Example:

        add_type("x-world/x-vrml" => qw(wrl vrml));

  * add_encoding( $type, @ext )

    Associate a list of file extensions with an encoding type. Example:

     add_encoding("x-gzip" => "gz");

  * read_media_types( @files )

    Parse media types files and add the type mappings found there. Example:

        read_media_types("conf/mime.types");


pkgId: af0f127bbc519bbce97513dd0f8e20ab20effb585e3a5a02960e3008271a155a
name: perl-LWP-Online
arch: src
version: 1.08
epoch: 0
release: 5.1.1
summary: Does your process have access to the web
url: http://search.cpan.org/dist/LWP-Online/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-LWP-Online-1.08-5.1.1.src.rpm
checksum_type: sha256
description:
  This module attempts to answer, as accurately as it can, one of the
  nastiest technical questions there is.

  *Am I on the internet?*

  The answer is useful in a wide range of decisions. For example...

  _Should my test scripts run the online portion of the tests or just skip
  them?_

  _Do I try to fetch fresh data from the server?_

  _If my request to the server breaks, is it because I'm offline, or because
  the server is offline?_

  And so on, and so forth.

  But a host of networking and security issues make this problem very
  difficult. There are firewalls, proxies (both well behaved and badly
  behaved). We might not have DNS. We might not have a network card at all!

  You might have network access, but only to a for-money wireless network
  that responds to ever HTTP request with a page asking you to enter your
  credit card details for paid access. Which means you don't "REALLY" have
  access.

  The mere nature of the question makes it practically unsolvable.

  But with the answer being so useful, and the only other alternative being
  to ask the user "duh... are you online?" (when you might not have a user at
  all) it's my gut feeling that it is worthwhile at least making an attempt
  to solve the problem, if only in a limited way.


pkgId: e86cf07324223e1e00fecfac11eb19e492f86c3eec4263403693fd85ab9ac2a4
name: perl-LWP-Protocol-https
arch: src
version: 6.03
epoch: 0
release: 4.1.1
summary: Provide https support for LWP::UserAgent
url: http://search.cpan.org/dist/LWP-Protocol-https/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-LWP-Protocol-https-6.03-4.1.1.src.rpm
checksum_type: sha256
description:
  The LWP::Protocol::https module provides support for using https schemed
  URLs with LWP. This module is a plug-in to the LWP protocol handling, so
  you don't use it directly. Once the module is installed LWP is able to
  access sites using HTTP over SSL/TLS.

  If hostname verification is requested by LWP::UserAgent's 'ssl_opts', and
  neither 'SSL_ca_file' nor 'SSL_ca_path' is set, then 'SSL_ca_file' is
  implied to be the one provided by Mozilla::CA. If the Mozilla::CA module
  isn't available SSL requests will fail. Either install this module, set up
  an alternative 'SSL_ca_file' or disable hostname verification.

  This module used to be bundled with the libwww-perl, but it was unbundled
  in v6.02 in order to be able to declare its dependencies properly for the
  CPAN tool-chain. Applications that need https support can just declare
  their dependency on LWP::Protocol::https and will no longer need to know
  what underlying modules to install.


pkgId: 6c388a6235aa067c38fe5f2e53d765498b0279fbe8a6945249b56bbddaec6489
name: perl-Lexical-Persistence
arch: src
version: 1.020
epoch: 0
release: 5.1.1
summary: Persistent lexical variable values for arbitrary calls
url: http://search.cpan.org/dist/Lexical-Persistence/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Lexical-Persistence-1.020-5.1.1.src.rpm
checksum_type: sha256
description:
  Lexical::Persistence does a few things, all related. Note that all the
  behaviors listed here are the defaults. Subclasses can override nearly every
  aspect of Lexical::Persistence's behavior.

  Lexical::Persistence lets your code access persistent data through lexical
  variables. This example prints "some value" because the value of $x perists in
  the $lp object between setter() and getter().


pkgId: dcb35f981920a3d313e7819a1693e5e7fb9b3bb30da69fe1241f1d24bd03c288
name: perl-Lingua-EN-Inflect
arch: src
version: 1.893
epoch: 0
release: 4.1.1
summary: Convert singular to plural. Select "a" or "an".
url: http://search.cpan.org/dist/Lingua-EN-Inflect/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Lingua-EN-Inflect-1.893-4.1.1.src.rpm
checksum_type: sha256
description:
  The exportable subroutines of Lingua::EN::Inflect provide plural
  inflections, "a"/"an" selection for English words, and manipulation of
  numbers as words

  Plural forms of all nouns, most verbs, and some adjectives are provided.
  Where appropriate, "classical" variants (for example: "brother" ->
  "brethren", "dogma" -> "dogmata", etc.) are also provided.

  Pronunciation-based "a"/"an" selection is provided for all English words,
  and most initialisms.

  It is also possible to inflect numerals (1,2,3) to ordinals (1st, 2nd, 3rd)
  and to english words ("one", "two", "three).

  In generating these inflections, Lingua::EN::Inflect follows the Oxford
  English Dictionary and the guidelines in Fowler's Modern English Usage,
  preferring the former where the two disagree.

  The module is built around standard British spelling, but is designed to
  cope with common American variants as well. Slang, jargon, and other
  English dialects are _not_ explicitly catered for.

  Where two or more inflected forms exist for a single word (typically a
  "classical" form and a "modern" form), Lingua::EN::Inflect prefers the more
  common form (typically the "modern" one), unless "classical" processing has
  been specified (see the "MODERN VS CLASSICAL INFLECTIONS" manpage).


pkgId: aaf4ef4e5f91c3f1a44daeabdcbba7da50b604616f8bdd07ffc0e501ac8d835d
name: perl-Lingua-EN-Inflect-Number
arch: src
version: 1.1
epoch: 0
release: 4.1.1
summary: Force number of words to singular or plural
url: http://search.cpan.org/dist/Lingua-EN-Inflect-Number/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Lingua-EN-Inflect-Number-1.1-4.1.1.src.rpm
checksum_type: sha256
description:
  This module extends the functionality of Lingua::EN::Inflect with three new
  functions available for export:

  number
      This takes a word, and determines its number. It returns 's' for
      singular, 'p' for plural, and 'ambig' for words that can be either
      singular or plural.

      Based on that:

  to_S / to_PL
      These take a word and convert it forcefully either to singular or to
      plural. 'Lingua::EN::Inflect' does funny things if you try to pluralise
      an already-plural word, but this module does the right thing.


pkgId: 3dbcc50f297e862126ab85ab01dd7f91192ab62e8f4e653db58f0f1fca116a67
name: perl-Lingua-EN-Sentence
arch: src
version: 0.25
epoch: 0
release: 11.1.1
summary: Module for splitting text into sentences.
url: http://search.cpan.org/dist/Lingua-EN-Sentence/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Lingua-EN-Sentence-0.25-11.1.1.src.rpm
checksum_type: sha256
description:
  The 'Lingua::EN::Sentence' module contains the function get_sentences,
  which splits text into its constituent sentences, based on a regular
  expression and a list of abbreviations (built in and given).

  Certain well know exceptions, such as abreviations, may cause incorrect
  segmentations. But some of them are already integrated into this code and
  are being taken care of. Still, if you see that there are words causing the
  get_sentences() to fail, you can add those to the module, so it notices
  them.


pkgId: ed039054fae9e3416d309fc1ade249d2bc838689608ac28e59e2f1f3cd1f84dc
name: perl-Lingua-Stem-Snowball
arch: src
version: 0.952
epoch: 0
release: 9.1.2
summary: Perl interface to Snowball stemmers
url: http://search.cpan.org/dist/Lingua-Stem-Snowball/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Lingua-Stem-Snowball-0.952-9.1.2.src.rpm
checksum_type: sha256
description:
  Stemming reduces related words to a common root form -- for instance,
  "horse", "horses", and "horsing" all become "hors". Most commonly, stemming
  is deployed as part of a search application, allowing searches for a given
  term to match documents which contain other forms of that term.

  Authors:
  --------
      Oleg Bartunov, <oleg at sai dot msu dot su>
      Teodor Sigaev, <teodor at stack dot net>
      Marvin Humphrey <marvin at rectangular dot com>


pkgId: f77012e527fec4c04b3490aa2deffb6b6338f8a7bb878e59822ba545d390b5b0
name: perl-Linux-Inotify2
arch: src
version: 1.22
epoch: 0
release: 22.1.1
summary: scalable directory/file change notification
url: http://www.cpan.org/modules/by-module/Linux/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Linux-Inotify2-1.22-22.1.1.src.rpm
checksum_type: sha256
description:
  This module implements an interface to the Linux 2.6.13 and later
  Inotify file/directory change notification sytem.


pkgId: 711e3e37f88049a7114e4d7497ce5019e0db81533b2e2562c0203e34266933ff
name: perl-List-AllUtils
arch: src
version: 0.02
epoch: 0
release: 4.1.1
summary: Combines List::Util and List::MoreUtils in one bite-sized package
url: http://search.cpan.org/dist/List-AllUtils
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-List-AllUtils-0.02-4.1.1.src.rpm
checksum_type: sha256
description:
  Are you sick of trying to remember whether a particular helper is defined
  in "List::Util" or "List::MoreUtils"? I sure am. Now you don't have to
  remember. This module will export all of the functions that either of
  those two modules defines.


pkgId: 3f14d2d20bccde6535a5957108839222856bf145700d652e6317902f6cd531c1
name: perl-List-MoreUtils
arch: src
version: 0.33
epoch: 0
release: 4.1.1
summary: Provide the stuff missing in List::Util
url: http://search.cpan.org/dist/List-MoreUtils/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-List-MoreUtils-0.33-4.1.1.src.rpm
checksum_type: sha256
description:
  *List::MoreUtils* provides some trivial but commonly needed functionality
  on lists which is not going to go into the List::Util manpage.

  All of the below functions are implementable in only a couple of lines of
  Perl code. Using the functions from this module however should give
  slightly better performance as everything is implemented in C. The
  pure-Perl implementation of these functions only serves as a fallback in
  case the C portions of this module couldn't be compiled on this machine.


pkgId: ad2271ba27702c8469a1b76ab2da9fcccace358fdcf3b3ecad6a78d1433c7a18
name: perl-Locale-Maketext-Gettext
arch: src
version: 1.28
epoch: 0
release: 9.1.1
summary: Joins the gettext and Maketext frameworks
url: http://search.cpan.org/dist/Locale-Maketext-Gettext/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Locale-Maketext-Gettext-1.28-9.1.1.src.rpm
checksum_type: sha256
description:
  Locale::Maketext::Gettext joins the GNU gettext and Maketext frameworks. It
  is a subclass of Locale::Maketext(3) that follows the way GNU gettext
  works. It works seamlessly, both in the sense of GNU gettext and Maketext.
  As a result, you enjoy both their advantages, and get rid of both their
  problems, too.


pkgId: 7df884a52faf6137e5bc299bd39b6ccaf4603eabb812efd81b0ec0461e792a8b
name: perl-Locale-Maketext-Lexicon
arch: src
version: 0.91
epoch: 0
release: 5.1.1
summary: Use other catalog formats in Maketext
url: http://search.cpan.org/dist/Locale-Maketext-Lexicon/
rpm_license: MIT
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build30
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Locale-Maketext-Lexicon-0.91-5.1.1.src.rpm
checksum_type: sha256
description:
  This module provides lexicon-handling modules to read from other
  localization formats, such as _Gettext_, _Msgcat_, and so on.

  If you are unfamiliar with the concept of lexicon modules, please consult
  the Locale::Maketext manpage and the 'webl10n' HTML files in the 'docs/'
  directory of this module.

  A command-line utility the xgettext.pl manpage is also installed with this
  module, for extracting translatable strings from source files.


pkgId: 9d476c498a7b52ce1f61bcbe510d1d9c8f782c5916e1f15c6ef727e35c2ec727
name: perl-LockFile-Simple
arch: src
version: 0.207
epoch: 0
release: 8.1.1
summary: simple file locking scheme
url: http://search.cpan.org/dist/LockFile-Simple/
rpm_license: GPL-2.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-LockFile-Simple-0.207-8.1.1.src.rpm
checksum_type: sha256
description:
  This simple locking scheme is not based on any file locking system calls
  such as 'flock()' or 'lockf()' but rather relies on basic file system
  primitives and properties, such as the atomicity of the 'write()' system
  call. It is not meant to be exempt from all race conditions, especially
  over NFS. The algorithm used is described below in the *ALGORITHM* section.

  It is possible to customize the locking operations to attempt locking once
  every 5 seconds for 30 times, or delete stale locks (files that are deemed
  too ancient) before attempting the locking.


pkgId: c1e2337c44ce95e9a258bce2b2bd61396a0eb3b67a27fb5d51ff99d44047d416
name: perl-Log-Any
arch: src
version: 0.14
epoch: 0
release: 4.1.1
summary: Bringing loggers and listeners together
url: http://search.cpan.org/dist/Log-Any/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Any-0.14-4.1.1.src.rpm
checksum_type: sha256
description:
  'Log::Any' allows CPAN modules to safely and efficiently log messages,
  while letting the application choose (or decline to choose) a logging
  mechanism such as 'Log::Dispatch' or 'Log::Log4perl'.

  'Log::Any' has a very tiny footprint and no dependencies beyond Perl 5.6,
  which makes it appropriate for even small CPAN modules to use. It defaults
  to 'null' logging activity, so a module can safely log without worrying
  about whether the application has chosen (or will ever choose) a logging
  mechanism.

  The application, in turn, may choose one or more logging mechanisms via
  Log::Any::Adapter.


pkgId: 39c47d7146f979128c59c18a2b7b60615e4e8918124a6d6e43edf7c1ad15daaa
name: perl-Log-Contextual
arch: src
version: 0.004001
epoch: 0
release: 4.1.1
summary: Simple logging interface with a contextual log
url: http://search.cpan.org/dist/Log-Contextual/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Contextual-0.004001-4.1.1.src.rpm
checksum_type: sha256
description:
  This module is a simple interface to extensible logging. It is bundled with
  a really basic logger, the Log::Contextual::SimpleLogger manpage, but in
  general you should use a real logger instead of that. For something more
  serious but not overly complicated, try the Log::Dispatchouli manpage (see
  the /SYNOPSIS manpage for example.)

  The reason for this module is to abstract your logging interface so that
  logging is as painless as possible, while still allowing you to switch from
  one logger to another.


pkgId: 0e6c973272ff9c09c961c251a092ec903889ab2c2a6d1229fa342c79d130a763
name: perl-Log-Dispatch
arch: src
version: 2.29
epoch: 0
release: 10.1.1
summary: Dispatches messages to one or more outputs
url: http://search.cpan.org/dist/Log-Dispatch/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Dispatch-2.29-10.1.1.src.rpm
checksum_type: sha256
description:
  This module manages a set of Log::Dispatch::* output objects that can be
  logged to via a unified interface.

  The idea is that you create a Log::Dispatch object and then add various
  logging objects to it (such as a file logger or screen logger). Then you
  call the 'log' method of the dispatch object, which passes the message to
  each of the objects, which in turn decide whether or not to accept the
  message and what to do with it.

  This makes it possible to call single method and send a message to a log
  file, via email, to the screen, and anywhere else, all with very little
  code needed on your part, once the dispatching object has been created.


pkgId: b27c8300596778b1c080f884e60741d0d487a7b3c6b6b0eac9edbe765a867e1c
name: perl-Log-Dispatch-Array
arch: src
version: 1.001
epoch: 0
release: 4.1.1
summary: Log events to an array
url: http://search.cpan.org/dist/Log-Dispatch-Array
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Dispatch-Array-1.001-4.1.1.src.rpm
checksum_type: sha256
description:
  This provides a Log::Dispatch log output system that appends logged events
  to an array reference. This is probably only useful for testing the
  logging of your code.


pkgId: 3cdafaa73fbb640acd9ecae4d894ef1715fa1cb70a7adefd75cfb74e6b9b68cb
name: perl-Log-Dispatch-Config
arch: src
version: 1.04
epoch: 0
release: 4.1.1
summary: Log4j for Perl
url: http://search.cpan.org/dist/Log-Dispatch-Config/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Dispatch-Config-1.04-4.1.1.src.rpm
checksum_type: sha256
description:
  Log::Dispatch::Config is a subclass of Log::Dispatch and provides a way to
  configure Log::Dispatch object with configulation file (default, in
  AppConfig format). I mean, this is log4j for Perl, not with all API
  compatibility though.


pkgId: 60a1d83be5dccd8c0e41f200c9a5526ea8924046643aac6bd9bbb8ff2eb5c25f
name: perl-Log-Dispatch-FileRotate
arch: src
version: 1.19
epoch: 0
release: 20.1.1
summary: Log to files that archive/rotate themselves
url: http://search.cpan.org/dist/Log-Dispatch-FileRotate
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Dispatch-FileRotate-1.19-20.1.1.src.rpm
checksum_type: sha256
description:
  This module provides a simple object for logging to files under the
  Log::Dispatch::* system, and automatically rotating them according to
  different constraints. This is basically a Log::Dispatch::File wrapper
  with additions. To that end the arguments

          name, min_level, filename and  mode

  behave the same as Log::Dispatch::File. So see its man page (perldoc
  Log::Dispatch::File)

  Authors:
  --------
      Mark Pfeiffer, <markpf@mlp-consulting.com.au>
       inspired by Dave Rolsky's, <autarchi@urth.org>, code :-)

      Kevin Goess <cpan@goess.org> suggested multiple writers should be supported.
       He also conned me into doing the time based stuff. Thanks Kevin! :-)

      Thanks also to Dan Waldheim for helping with some of the locking
       issues in a forked environment.

      And thanks to Stephen Gordon for his more portable code on lockfile naming.


pkgId: 4a5b7540d495eb67e471756c460dbb121cf7ff2e84bd45249cb0c5f2ab1c491a
name: perl-Log-Dispatchouli
arch: src
version: 2.005
epoch: 0
release: 4.1.1
summary: a simple wrapper around Log::Dispatch
url: http://search.cpan.org/dist/Log-Dispatchouli/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Dispatchouli-2.005-4.1.1.src.rpm
checksum_type: sha256
description:
  Log::Dispatchouli is a thin layer above the Log::Dispatch manpage and meant
  to make it dead simple to add logging to a program without having to think
  much about categories, facilities, levels, or things like that. It is meant
  to make logging just configurable enough that you can find the logs you
  want and just easy enough that you will actually log things.

  Log::Dispatchouli can log to syslog (if you specify a facility), standard
  error or standard output, to a file, or to an array in memory. That last
  one is mostly useful for testing.

  In addition to providing as simple a way to get a handle for logging
  operations, Log::Dispatchouli uses the String::Flogger manpage to process
  the things to be logged, meaning you can easily log data structures.
  Basically: strings are logged as is, arrayrefs are taken as (sprintf
  format, args), and subroutines are called only if needed. For more
  information read the the String::Flogger manpage docs.


pkgId: 04842fb204fc29d5d84dbce37bcb268f7c8186d5fbb9bdbc18c6c344ab465db2
name: perl-Log-Log4perl
arch: src
version: 1.36
epoch: 0
release: 4.1.1
summary: Log4j implementation for Perl
url: http://search.cpan.org/dist/Log-Log4perl/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Log-Log4perl-1.36-4.1.1.src.rpm
checksum_type: sha256
description:
  Log::Log4perl lets you remote-control and fine-tune the logging behaviour
  of your system from the outside. It implements the widely popular
  (Java-based) Log4j logging package in pure Perl.

  *For a detailed tutorial on Log::Log4perl usage, please read*

      http://www.perl.com/pub/a/2002/09/11/log4perl.html

  Logging beats a debugger if you want to know what's going on in your code
  during runtime. However, traditional logging packages are too static and
  generate a flood of log messages in your log files that won't help you.

  'Log::Log4perl' is different. It allows you to control the number of
  logging messages generated at three different levels:

  * *

    At a central location in your system (either in a configuration file or
    in the startup code) you specify _which components_ (classes, functions)
    of your system should generate logs.

  * *

    You specify how detailed the logging of these components should be by
    specifying logging _levels_.

  * *

    You also specify which so-called _appenders_ you want to feed your log
    messages to ("Print it to the screen and also append it to /tmp/my.log")
    and which format ("Write the date first, then the file name and line
    number, and then the log message") they should be in.

  This is a very powerful and flexible mechanism. You can turn on and off
  your logs at any time, specify the level of detail and make that dependent
  on the subsystem that's currently executed.

  Let me give you an example: You might find out that your system has a
  problem in the 'MySystem::Helpers::ScanDir' component. Turning on detailed
  debugging logs all over the system would generate a flood of useless log
  messages and bog your system down beyond recognition. With 'Log::Log4perl',
  however, you can tell the system: "Continue to log only severe errors to
  the log file. Open a second log file, turn on full debug logs in the
  'MySystem::Helpers::ScanDir' component and dump all messages originating
  from there into the new log file". And all this is possible by just
  changing the parameters in a configuration file, which your system can
  re-read even while it's running!


pkgId: 3c10fb55234283a1c0226552ce524dee6e41c588f2a2af0d9b84040bede63563
name: perl-MIME-EncWords
arch: src
version: 1.012.4
epoch: 0
release: 5.1.1
summary: deal with RFC 2047 encoded words (improved)
url: http://search.cpan.org/dist/MIME-EncWords/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MIME-EncWords-1.012.4-5.1.1.src.rpm
checksum_type: sha256
description:
  Fellow Americans, you probably won't know what the hell this module is for.
  Europeans, Russians, et al, you probably do. ':-)'.

  For example, here's a valid MIME header you might get:

        From: =?US-ASCII?Q?Keith_Moore?= <moore@cs.utk.edu>
        To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= <keld@dkuug.dk>
        CC: =?ISO-8859-1?Q?Andr=E9_?= Pirard <PIRARD@vm1.ulg.ac.be>
        Subject: =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=
         =?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=
         =?US-ASCII?Q?.._cool!?=

  The fields basically decode to (sorry, I can only approximate the Latin
  characters with 7 bit sequences /o and 'e):

        From: Keith Moore <moore@cs.utk.edu>
        To: Keld J/orn Simonsen <keld@dkuug.dk>
        CC: Andr'e  Pirard <PIRARD@vm1.ulg.ac.be>
        Subject: If you can read this you understand the example... cool!

  *Supplement*: Fellow Americans, Europeans, you probably won't know what the
  hell this module is for. East Asians, et al, you probably do. '(^_^)'.

  For example, here's a valid MIME header you might get:

        Subject: =?EUC-KR?B?sNTAuLinKGxhemluZXNzKSwgwvzB9ri7seIoaW1w?=
         =?EUC-KR?B?YXRpZW5jZSksILGzuLgoaHVicmlzKQ==?=

  The fields basically decode to (sorry, I cannot approximate the non-Latin
  multibyte characters with any 7 bit sequences):

        Subject: ???(laziness), ????(impatience), ??(hubris)


pkgId: 4df6ff3c6ace3408586fccb8d01602e82a69f3b77fadfacbd011a2aa180bdec3
name: perl-MIME-Lite
arch: src
version: 3.028
epoch: 0
release: 6.1.1
summary: Module for Generating MIME messages
url: http://cpan.org/modules/by-module/MIME/
rpm_license: Artistic-1.0 or GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MIME-Lite-3.028-6.1.1.src.rpm
checksum_type: sha256
description:
  MIME::Lite is intended as a simple, standalone module for generating
  (not parsing!) MIME messages... specifically, it allows you to output a
  simple, decent single- or multi-part message with text or binary
  attachments. It does not require that you have the Mail:: or MIME::
  modules installed.


pkgId: 3bf6f36e0612609242fb21ada04431a30f5d792c0c0d5b79b4ef5dc65bdc71e1
name: perl-MIME-Types
arch: src
version: 1.34
epoch: 0
release: 4.1.1
summary: MIME-Type Determination
url: http://cpan.org/modules/by-module/MIME/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MIME-Types-1.34-4.1.1.src.rpm
checksum_type: sha256
description:
  MIME types are used in MIME entities, for instance as part of e-mail
  and HTTP traffic. Sometimes real knowledge about a mime-type is need.
  This module will supply it.


pkgId: 4583c3fa3ba01c5ad82e233c61ef3f00d4c80780a665b4982f14676b1b646e01
name: perl-MLDBM
arch: src
version: 2.04
epoch: 0
release: 17.1.1
summary: store multidimensional hash structures in tied hashes
url: http://cpan.org/modules/by-module/MLDBM/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MLDBM-2.04-17.1.1.src.rpm
checksum_type: sha256
description:
  MLDBM, the Perl module that can be used to store multidimensional hash
  structures in tied hashes (including DBM files).



  Authors:
  --------
      Sarathy <gsar@umich.edu>


pkgId: 805c581fc11f8bbca5c58f793792e0eaf9af5071e7cc13d3ceb1269c914c7eeb
name: perl-MLDBM-Sync
arch: src
version: 0.30
epoch: 0
release: 402.1.1
summary: Perl module for safe concurrent access to MLDBM databases
url: http://cpan.org/modules/by-module/MLDBM
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MLDBM-Sync-0.30-402.1.1.src.rpm
checksum_type: sha256
description:
  This module wraps around the MLDBM interface, by handling concurrent
  access to MLDBM databases with file locking, and flushes i/o explicity
  per lock/unlock. The new [Read]Lock()/UnLock() API can be used to
  serialize requests logically and improve performance for bundled reads
  & writes.



  Authors:
  --------
      Joshua Chamas <asp@chamas.com>


pkgId: 860f361d8898d8ce0084a0ec0c5c0b2fbbff1617ae1be07a88c4fdbc42cd5088
name: perl-MRO-Compat
arch: src
version: 0.11
epoch: 0
release: 13.1.1
summary: Mro::* interface compatibility for Perls < 5.9.5
url: http://search.cpan.org/dist/MRO-Compat/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MRO-Compat-0.11-13.1.1.src.rpm
checksum_type: sha256
description:
  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.

  Authors:
  --------
      Brandon L. Black, <blblack@gmail.com>


pkgId: a7327c82039bd1f24e0ed301e3026e770dafbcd13935d2d3dcf2bb7ba7baf8f4
name: perl-Mac-PropertyList
arch: src
version: 1.37
epoch: 0
release: 2.1.1
summary: Work with Mac plists at a low level
url: http://search.cpan.org/dist/Mac-PropertyList/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mac-PropertyList-1.37-2.1.1.src.rpm
checksum_type: sha256
description:
  This module is a low-level interface to the Mac OS X Property List (plist)
  format. You probably shouldn't use this in applications--build interfaces
  on top of this so you don't have to put all the heinous multi-level object
  stuff where people have to look at it.

  You can parse a plist file and get back a data structure. You can take that
  data structure and get back the plist as XML. If you want to change the
  structure inbetween that's your business. :)

  You don't need to be on Mac OS X to use this. It simply parses and
  manipulates a text format that Mac OS X uses.


pkgId: b119e2c5f16057d8a0e9550505bfd41e36372a0316f0be2516d5d655c79867e6
name: perl-Mail-DKIM
arch: src
version: 0.39
epoch: 0
release: 17.1.1
summary: Signs/verifies Internet mail with DKIM/DomainKey signatures
url: http://search.cpan.org/dist/Mail-DKIM/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mail-DKIM-0.39-17.1.1.src.rpm
checksum_type: sha256
description:
  This module implements the various components of the DKIM and DomainKeys
  message-signing and verifying standards for Internet mail. It currently
  tries to implement these specifications:

  * RFC4871, for DKIM

  * RFC4870, for DomainKeys

  The module uses an object-oriented interface. You use one of two different
  classes, depending on whether you are signing or verifying a message. To
  sign, use the the Mail::DKIM::Signer manpage class. To verify, use the the
  Mail::DKIM::Verifier manpage class. Simple, eh?


pkgId: 43cec91794b1f1db75f88de2dd7ebe74f4386e7823232b81db82e2eacc5ffa79
name: perl-Mail-Mbox-MessageParser
arch: src
version: 1.5002
epoch: 0
release: 17.1.1
summary: A fast and simple mbox folder reader
url: http://cpan.org/modules/by-module/Mail/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mail-Mbox-MessageParser-1.5002-17.1.1.src.rpm
checksum_type: sha256
description:
  Mail::Mbox::MessageParser is a feature-poor but very fast mbox parser.
  It uses the best of three strategies for parsing a mailbox: either
  using cached folder information, GNU grep, or highly optimized Perl.



  Authors:
  --------
      David Coppit <david@coppit.org>


pkgId: d3896ea45b1751d8d99234aa295f95682a85a172f08885abd6b73b967b8bb1b6
name: perl-Mail-SPF
arch: src
version: 2.008
epoch: 0
release: 6.1.1
summary: An object-oriented implementation of Sender Policy Framework
url: http://search.cpan.org/perldoc?Mail::SPF
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mail-SPF-2.008-6.1.1.src.rpm
checksum_type: sha256
description:
  Mail::SPF is an object-oriented implementation of Sender Policy Framework
  (SPF). See http://www.openspf.org for more information about SPF.

  This class collection aims to fully conform to the SPF specification (RFC 4408)
  so as to serve both as a production quality SPF implementation and as a
  reference for other developers of SPF implementations.


pkgId: c4e4614d39b13c0bdf1eb7c6362cd3d73bc7f4270793f9d1a54441ad81872b27
name: perl-Mail-Sender
arch: src
version: 0.8.21
epoch: 0
release: 4.1.1
summary: module for sending mails with attachments through an SMTP server
url: http://search.cpan.org/dist/Mail-Sender/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mail-Sender-0.8.21-4.1.1.src.rpm
checksum_type: sha256
description:
  'Mail::Sender' provides an object oriented interface to sending mails. It
  doesn't need any outer program. It connects to a mail server directly from
  Perl, using Socket.

  Sends mails directly from Perl through a socket connection.


pkgId: 71174438eec2a1bd3369fa2b471210528bb4666cc8c5aa6812a993603f832953
name: perl-Mail-Sendmail
arch: src
version: 0.79
epoch: 0
release: 121.1.1
summary: Simple platform independent mailer
url: http://www.cpan.org/modules/by-module/Mail/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build33
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mail-Sendmail-0.79-121.1.1.src.rpm
checksum_type: sha256
description:
  Simple platform independent e-mail from your perl script.



  Authors:
  --------
      Milivoj Ivkovic <mi@alma.ch>


pkgId: 0c1f938234602da204846671cd5dbf56e686262d27c2378b91662368bb9acac3
name: perl-Makefile-DOM
arch: src
version: 0.006
epoch: 0
release: 5.1.1
summary: Simple DOM parser for Makefiles
url: http://search.cpan.org/dist/Makefile-DOM/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Makefile-DOM-0.006-5.1.1.src.rpm
checksum_type: sha256
description:
  This libary can serve as an advanced lexer for (GNU) makefiles. It parses
  makefiles as "documents" and the parsing is lossless. The results are data
  structures similar to DOM trees. The DOM trees hold every single bit of the
  information in the original input files, including white spaces, blank
  lines and makefile comments. That means it's possible to reproduce the
  original makefiles from the DOM trees. In addition, each node of the DOM
  trees is modifiable and so is the whole tree, just like the PPI module used
  for Perl source parsing and the HTML::TreeBuilder module used for parsing
  HTML source.


pkgId: b8ef8973b8c9212183e5b5dff1b59d67c631c8b40009c8fd1f761675bdbb1984
name: perl-Math-BigInt
arch: src
version: 1.997
epoch: 0
release: 5.1.1
summary: Arbitrary size integer/float math package
url: http://search.cpan.org/dist/Math-BigInt/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Math-BigInt-1.997-5.1.1.src.rpm
checksum_type: sha256
description:
  All operators (including basic math operations) are overloaded if you
  declare your big integers as

    $i = new Math::BigInt '123_456_789_123_456_789';

  Operations with overloaded operators preserve the arguments which is
  exactly what you expect.

  * Input

    Input values to these routines may be any string, that looks like a
    number and results in an integer, including hexadecimal and binary
    numbers.

    Scalars holding numbers may also be passed, but note that non-integer
    numbers may already have lost precision due to the conversion to float.
    Quote your input if you want BigInt to see all the digits:

    	$x = Math::BigInt->new(12345678890123456789);	# bad
    	$x = Math::BigInt->new('12345678901234567890');	# good

    You can include one underscore between any two digits.

    This means integer values like 1.01E2 or even 1000E-2 are also accepted.
    Non-integer values result in NaN.

    Hexadecimal (prefixed with "0x") and binary numbers (prefixed with "0b")
    are accepted, too. Please note that octal numbers are not recognized by
    new(), so the following will print "123":

    	perl -MMath::BigInt -le 'print Math::BigInt->new("0123")'

    To convert an octal number, use from_oct();

    	perl -MMath::BigInt -le 'print Math::BigInt->from_oct("0123")'

    Currently, Math::BigInt::new() defaults to 0, while Math::BigInt::new('')
    results in 'NaN'. This might change in the future, so use always the
    following explicit forms to get a zero or NaN:

    	$zero = Math::BigInt->bzero();
    	$nan = Math::BigInt->bnan();

    'bnorm()' on a BigInt object is now effectively a no-op, since the
    numbers are always stored in normalized form. If passed a string, creates
    a BigInt object from the input.

  * Output

    Output values are BigInt objects (normalized), except for the methods
    which return a string (see the SYNOPSIS manpage).

    Some routines ('is_odd()', 'is_even()', 'is_zero()', 'is_one()',
    'is_nan()', etc.) return true or false, while others ('bcmp()',
    'bacmp()') return either undef (if NaN is involved), <0, 0 or >0 and are
    suited for sort.


pkgId: c8a308a17b28e3e4357e7b9df94a399aa8c64950016e674e4ac5cc28fa7c93d7
name: perl-Math-Calc-Units
arch: src
version: 1.07
epoch: 0
release: 2.1.1
summary: Human-readable unit-aware calculator
url: http://search.cpan.org/dist/Math-Calc-Units/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build02
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Math-Calc-Units-1.07-2.1.1.src.rpm
checksum_type: sha256
description:
  Math::Calc::Units is a simple calculator that keeps track of units. It
  currently handles combinations of byte sizes and duration only, although adding
  any other multiplicative types is easy. Any unknown type is treated as a unique
  user type (with some effort to map English plurals to their singular forms).

  The primary intended use is via the ucalc script that prints out all of the
  "readable" variants of a value. For example, "3 bytes" will only produce "3
  byte", but "3 byte / sec" produces the original along with "180 byte / minute",
  "10.55 kilobyte / hour", etc.


pkgId: 6335c89589954f1ba0a3697430709142b709253ce391cb6b6af3915ed9265e41
name: perl-Math-Round
arch: src
version: 0.06
epoch: 0
release: 8.1.1
summary: Perl extension for rounding numbers
url: http://search.cpan.org/dist/Math-Round/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Math-Round-0.06-8.1.1.src.rpm
checksum_type: sha256
description:
  *Math::Round* supplies functions that will round numbers in different ways.
  The functions *round* and *nearest* are exported by default; others are
  available as described below. "use ... qw(:all)" exports all functions.


pkgId: 671d63f510f4a4d5013449f4f116f80b08fba259115812356de600247b96afbf
name: perl-Mcrypt
arch: src
version: 2.5.7.0
epoch: 0
release: 72.1.1
summary: An Autoload-Capable Interface Module for libmcrypt
url: http://search.cpan.org/CPAN/authors/id/J/JE/JESUS/
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mcrypt-2.5.7.0-72.1.1.src.rpm
checksum_type: sha256
description:
  The Mcrypt module provides a simple and intuitive Perl abstraction of
  the libmcrypt cryptography library.  It provides mechanisms for
  encoding and decoding Perl scalars.



  Authors:
  --------
      Theo Schlossnagle <jesus@omniti.com>


pkgId: 9b019bb51d733b4d316d18f1e0d6be50fda07be100bca483c8b5d1b36c20b9f2
name: perl-Meta-Builder
arch: src
version: 0.003
epoch: 0
release: 4.1.1
summary: Tools for creating Meta objects to track custom metrics.
url: http://search.cpan.org/dist/Meta-Builder/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Meta-Builder-0.003-4.1.1.src.rpm
checksum_type: sha256
description:
  Meta programming is becomming more and more popular. The popularity of Meta
  programming comes from the fact that many problems are made significantly
  easier. There are a few specialized Meta tools out there, for instance the
  Class:MOP manpage which is used by the Moose manpage to track class
  metadata.

  Meta::Builder is designed to be a generic tool for writing Meta objects.
  Unlike specialized tools, Meta::Builder makes no assumptions about what
  metrics you will care about. Meta::Builder also mkaes it simple for others
  to extend your meta-object based tools by providing hooks for other
  packages to add metrics to your meta object.

  If a specialized Meta object tool is available ot meet your needs please
  use it. However if you need a simple Meta object to track a couple metrics,
  use Meta::Builder.

  Meta::Builder is also low-sugar and low-dep. In most cases you will not
  want a class that needs a meta object to use your meta-object class
  directly. Rather you will usually want to create a sugar class that exports
  enhanced API functions that manipulate the meta object.


pkgId: b508f9a8adb085d19306e1a75027421096e116555afe3992896eb1bfa8389c87
name: perl-Mixin-Linewise
arch: src
version: 0.003
epoch: 0
release: 10.1.1
summary: Write your linewise code for handles; this does the rest
url: http://search.cpan.org/dist/Mixin-Linewise/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mixin-Linewise-0.003-10.1.1.src.rpm
checksum_type: sha256
description:
  It's boring to deal with opening files for IO, converting strings to
  handle-like objects, and all that. With the Mixin::Linewise::Readers
  manpage and the Mixin::Linewise::Writers manpage, you can just write a
  method to handle handles, and methods for handling strings and filenames
  are added for you.


pkgId: 6294d707e44c109943bfb0db49bcd35e19cbe1e13281874ee8af8933d7d3c3c5
name: perl-Module-Build
arch: src
version: 0.4003
epoch: 0
release: 2.1.1
summary: Build and install Perl modules
url: http://search.cpan.org/dist/Module-Build/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Build-0.4003-2.1.1.src.rpm
checksum_type: sha256
description:
  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 in a
  much more straightforward way than with MakeMaker. 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. In fact, you don't even need a shell,
  so even platforms like MacOS (traditional) can use it fairly easily. Its
  only prerequisites are modules that are included with perl 5.6.0, and it
  works fine on perl 5.005 if you can install a few additional modules.

  Authors:
  --------
      Ken Williams <kwilliams@cpan.org>


pkgId: c5ff96ce5d3603ab96a36e5999c73e5d15c09a97d9adf4412af4d8a23636d68a
name: perl-Module-Depends
arch: src
version: 0.15
epoch: 0
release: 5.1.1
summary: identify the dependencies of a distribution
url: http://search.cpan.org/dist/Module-Depends/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Depends-0.15-5.1.1.src.rpm
checksum_type: sha256
description:
  Module::Depends extracts module dependencies from an unpacked distribution
  tree.

  Module::Depends only evaluates the META.yml shipped with a distribution.
  This won't be effective until all distributions ship META.yml files, so we
  suggest you take your life in your hands and look at
  Module::Depends::Intrusive.


pkgId: cf0bc289e3dfe52e0e23b6d5c7d386d308feb5e60eb623300218f9309cda7aaf
name: perl-Module-Find
arch: src
version: 0.11
epoch: 0
release: 4.1.1
summary: Find and use installed modules in a (sub)category
url: http://search.cpan.org/dist/Module-Find/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Find-0.11-4.1.1.src.rpm
checksum_type: sha256
description:
  Module::Find lets you find and use modules in categories. This can be very
  useful for auto-detecting driver or plugin modules. You can differentiate
  between looking in the category itself or in all subcategories.

  If you want Module::Find to search in a certain directory on your harddisk
  (such as the plugins directory of your software installation), make sure
  you modify '@INC' before you call the Module::Find functions.


pkgId: 56b78d3ff73f707288b387a5c8bb1b899ec090a268136ebd06809cc002553d1b
name: perl-Module-Implementation
arch: src
version: 0.05
epoch: 0
release: 5.1.1
summary: Loads one of several alternate underlying implementations for a module
url: http://search.cpan.org/dist/Module-Implementation/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Implementation-0.05-5.1.1.src.rpm
checksum_type: sha256
description:
  This module abstracts out the process of choosing one of several underlying
  implementations for a module. This can be used to provide XS and pure Perl
  implementations of a module, or it could be used to load an implementation
  for a given OS or any other case of needing to provide multiple
  implementations.

  This module is only useful when you know all the implementations ahead of
  time. If you want to load arbitrary implementations then you probably want
  something like a plugin system, not this module.


pkgId: 75580f9ebce02886f2f6e267dc4a82f640193e7a4385e03ec592a3d39c0170fe
name: perl-Module-Info
arch: src
version: 0.32
epoch: 0
release: 10.1.1
summary: Information about Perl modules
url: http://search.cpan.org/dist/Module-Info/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Info-0.32-10.1.1.src.rpm
checksum_type: sha256
description:
  Module::Info gives you information about Perl modules *without actually
  loading the module*. It actually isn't specific to modules and should work
  on any perl code.


pkgId: 3dc76974e0aa9c95251c1d0c62e3bb25524dca59540680315c5b5b4e2e1290e2
name: perl-Module-Install
arch: src
version: 1.04
epoch: 0
release: 5.1.1
summary: Standalone, extensible Perl module installer
url: http://search.cpan.org/dist/Module-Install/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Install-1.04-5.1.1.src.rpm
checksum_type: sha256
description:
  *Module::Install* is a package for writing installers for CPAN (or
  CPAN-like) distributions that are clean, simple, minimalist, act in a
  strictly correct manner with the ExtUtils::MakeMaker manpage, and will run
  on any Perl installation version 5.005 or newer.

  The intent is to make it as easy as possible for CPAN authors (and
  especially for first-time CPAN authors) to have installers that follow all
  the best practices for distribution installation, but involve as much DWIM
  (Do What I Mean) as possible when writing them.


pkgId: b806da1a0a6fc9ddb64828e5efd34109281d88a24a7f6f35b3c4b5e818e3e797
name: perl-Module-Refresh
arch: src
version: 0.17
epoch: 0
release: 6.1.1
summary: Refresh INC files when updated on disk
url: http://search.cpan.org/dist/Module-Refresh/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Refresh-0.17-6.1.1.src.rpm
checksum_type: sha256
description:
  This module is a generalization of the functionality provided by the
  Apache::StatINC manpage and the Apache::Reload manpage. It's designed to
  make it easy to do simple iterative development when working in a
  persistent environment.

  It does not require mod_perl.


pkgId: 31ca912c394247950dfa439a959a6699fc0490cdb686069adf8dd50abaf431c5
name: perl-Module-Runtime
arch: src
version: 0.013
epoch: 0
release: 4.1.1
summary: runtime module handling
url: http://search.cpan.org/dist/Module-Runtime/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Runtime-0.013-4.1.1.src.rpm
checksum_type: sha256
description:
  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, but there's a good chance of it changing in Perl 5.18.

  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.


pkgId: ceecc44304b285fd5c4a339db61bf03a4d5c8eecf7333e4e52947a0a920cb7f0
name: perl-Module-Signature
arch: src
version: 0.68
epoch: 0
release: 4.1.1
summary: Module signature file manipulation
url: http://search.cpan.org/dist/Module-Signature/
rpm_license: CC0-1.0 and (GPL-1.0+ or Artistic-1.0)
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Signature-0.68-4.1.1.src.rpm
checksum_type: sha256
description:
  *Module::Signature* adds cryptographic authentications to CPAN
  distributions, via the special _SIGNATURE_ file.

  If you are a module user, all you have to do is to remember to run
  'cpansign -v' (or just 'cpansign') before issuing 'perl Makefile.PL' or
  'perl Build.PL'; that will ensure the distribution has not been tampered
  with.

  Module authors can easily add the _SIGNATURE_ file to the distribution
  tarball; see the /NOTES manpage below for how to do it as part of 'make
  dist'.

  If you _really_ want to sign a distribution manually, simply add
  'SIGNATURE' to _MANIFEST_, then type 'cpansign -s' immediately before 'make
  dist'. Be sure to delete the _SIGNATURE_ file afterwards.

  Please also see the /NOTES manpage about _MANIFEST.SKIP_ issues, especially
  if you are using *Module::Build* or writing your own _MANIFEST.SKIP_.


pkgId: 95fb4bf6b8c9ed9bcccb743bec6d397b9d583ed171843918a708031cce1d52f7
name: perl-Module-Starter
arch: src
version: 1.58
epoch: 0
release: 5.1.1
summary: a simple starter kit for any module
url: http://search.cpan.org/dist/Module-Starter/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Module-Starter-1.58-5.1.1.src.rpm
checksum_type: sha256
description:
  This is the core module for Module::Starter. If you're not looking to
  extend or alter the behavior of this module, you probably want to look at
  the module-starter manpage instead.

  Module::Starter is used to create a skeletal CPAN distribution, including
  basic builder scripts, tests, documentation, and module code. This is done
  through just one method, 'create_distro'.


pkgId: 6384b1599f69b80b51be2b7629da787bac01f5d7ed104b65ad6a96073e62c56e
name: perl-Moo
arch: src
version: 0.009013
epoch: 0
release: 4.1.1
summary: Minimalist Object Orientation (with Moose compatiblity)
url: http://search.cpan.org/dist/Moo/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Moo-0.009013-4.1.1.src.rpm
checksum_type: sha256
description:
  This module is an extremely light-weight, high-performance the Moose
  manpage replacement. It also avoids depending on any XS modules to allow
  simple deployments. The name 'Moo' is based on the idea that it provides
  almost -but not quite- two thirds of the Moose manpage.

  Unlike 'Mouse' this module does not aim at full the Moose manpage
  compatibility. See the /INCOMPATIBILITIES manpage for more details.


pkgId: 5ebbd329c3d70f8fdf4202c842eadc2cc038687f99fccb2e6b5343fbd421f4b6
name: perl-Moose
arch: src
version: 2.0602
epoch: 0
release: 4.1.1
summary: A postmodern object system for Perl 5
url: http://search.cpan.org/dist/Moose/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build16
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Moose-2.0602-4.1.1.src.rpm
checksum_type: sha256
description:
  Moose is an extension of the Perl 5 object system.

  The main goal of Moose is to make Perl 5 Object Oriented programming
  easier, more consistent, and less tedious. With Moose you can think more
  about what you want to do and less about the mechanics of OOP.

  Additionally, Moose is built on top of the Class::MOP manpage, which is a
  metaclass system for Perl 5. This means that Moose not only makes building
  normal Perl 5 objects better, but it provides the power of metaclass
  programming as well.


pkgId: 8b9b341abd971c86bb8dad306619e685765c8e7bed423b103831b561741e77cb
name: perl-Moose-Autobox
arch: src
version: 0.11
epoch: 0
release: 4.1.1
summary: Autoboxed wrappers for Native Perl datatypes
url: http://search.cpan.org/dist/Moose-Autobox/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Moose-Autobox-0.11-4.1.1.src.rpm
checksum_type: sha256
description:
  Moose::Autobox provides an implementation of SCALAR, ARRAY, HASH & CODE for
  use with the autobox manpage. It does this using a hierarchy of roles in a
  manner similar to what Perl 6 _might_ do. This module, like the Class::MOP
  manpage and the Moose manpage, was inspired by my work on the Perl 6 Object
  Space, and the 'core types' implemented there.

  A quick word about autobox
      The the autobox manpage module provides the ability for calling
      'methods' on normal Perl values like Scalars, Arrays, Hashes and Code
      references. This gives the illusion that Perl's types are first-class
      objects. However, this is only an illusion, albeit a very nice one. I
      created this module because the autobox manpage itself does not
      actually provide an implementation for the Perl types but instead only
      provides the 'hooks' for others to add implementation too.

  Is this for real? or just play?
      Several people are using this module in serious applications and it
      seems to be quite stable. The underlying technologies of the autobox
      manpage and the Moose::Role manpage are also considered stable. There
      is some performance hit, but as I am fond of saying, nothing in life is
      free. If you have any questions regarding this module, either email me,
      or stop by #moose on irc.perl.org and ask around.

  Adding additional methods
      *Moose::Autobox* asks the autobox manpage to use the
      *Moose::Autobox::** namespace prefix so as to avoid stepping on the
      toes of other the autobox manpage modules. This means that if you want
      to add methods to a particular perl type (i.e. - monkeypatch), then you
      must do this:

        sub Moose::Autobox::SCALAR::bar { 42 }

      instead of this:

        sub SCALAR::bar { 42 }

      as you would with vanilla autobox.


pkgId: 18e3991017e3812c349364fec1b6291f5be166b829b7b0dfd5d5e3caffcf07ea
name: perl-MooseX-Aliases
arch: src
version: 0.10
epoch: 0
release: 5.1.1
summary: easy aliasing of methods and attributes in Moose
url: http://search.cpan.org/dist/MooseX-Aliases/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Aliases-0.10-5.1.1.src.rpm
checksum_type: sha256
description:
  The MooseX::Aliases module will allow you to quickly alias methods in
  Moose. It provides an alias parameter for 'has()' to generate aliased
  accessors as well as the standard ones. Attributes can also be initialized
  in the constructor via their aliased names.

  You can create more than one alias at once by passing a listref:

      has ip_addr => (
          alias => [ qw(ipAddr ip) ],
      );


pkgId: 9b4c203439bcf0af70a31b9addc042bd99ea7b56016e276b572532cdac3c2113
name: perl-MooseX-App-Cmd
arch: src
version: 0.07
epoch: 0
release: 4.1.1
summary: Command module for MooseX
url: http://search.cpan.org/dist/MooseX-App-Cmd
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-App-Cmd-0.07-4.1.1.src.rpm
checksum_type: sha256
description:
  This module marries App::Cmd with MooseX::Getopt.

  Use it like App::Cmd advises (especially see App::Cmd::Tutorial), swapping
  App::Cmd::Command for MooseX::App::Cmd::Command.

  Then you can write your moose commands as moose classes, with
  MooseX::Getopt defining the options for you instead of "opt_spec"
  returning a Getopt::Long::Descriptive spec.


pkgId: e3c5a7da00e46f81567b2e7bd80c2471560382d31a20669fad6dfd892260cad0
name: perl-MooseX-AttributeHelpers
arch: src
version: 0.23
epoch: 0
release: 8.1.1
summary: Extend your Attribute Interfaces
url: http://search.cpan.org/~drolsky/MooseX-AttributeHelpers-0.23/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build12
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-AttributeHelpers-0.23-8.1.1.src.rpm
checksum_type: sha256
description:
  This distribution is deprecated. The features it provides have been added to
  the Moose core code as Moose::Meta::Attribute::Native. This distribution should
  not be used by any new code.

  While Moose attributes provide you with a way to name your accessors, readers,
  writers, clearers and predicates, this library provides commonly used attribute
  helper methods for specific types of data.


pkgId: f01efc71c7caa33ab5822b19a4b9b298886f2c0c81d8acf31bd1c1a761051557
name: perl-MooseX-AuthorizedMethods
arch: src
version: 0.006
epoch: 0
release: 4.1.1
summary: Syntax sugar for authorized methods
url: http://search.cpan.org/dist/MooseX-AuthorizedMethods/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build11
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-AuthorizedMethods-0.006-4.1.1.src.rpm
checksum_type: sha256
description:
  This method exports the "authorized" declarator that makes a verification
  if the user has the required permissions before the acual invocation. The
  default verification method will take the "user" method result and call
  "roles" to list the roles given to that user.


pkgId: d7d583747c9f34f73c18376b2dc1a2debd2a2ef06692cc084a01f203b05bed03
name: perl-MooseX-ClassAttribute
arch: src
version: 0.26
epoch: 0
release: 4.1.1
summary: Declare class attributes Moose-style
url: http://search.cpan.org/dist/MooseX-ClassAttribute/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-ClassAttribute-0.26-4.1.1.src.rpm
checksum_type: sha256
description:
  This module allows you to declare class attributes in exactly the same way
  as object attributes, using 'class_has()' instead of 'has()'.

  You can use any feature of Moose's attribute declarations, including
  overriding a parent's attributes, delegation ('handles'), attribute traits,
  etc. All features should just work. The one exception is the "required"
  flag, which is not allowed for class attributes.

  The accessor methods for class attribute may be called on the class
  directly, or on objects of that class. Passing a class attribute to the
  constructor will not set that attribute.


pkgId: 03f3c074a107f84a5d2bea92f866fe4b91faf77a6c461e63a7f1ed4b47b28c5f
name: perl-MooseX-Clone
arch: src
version: 0.05
epoch: 0
release: 4.1.1
summary: Fine grained cloning support for Moose objects
url: http://search.cpan.org/dist/MooseX-Clone/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Clone-0.05-4.1.1.src.rpm
checksum_type: sha256
description:
  Out of the box Moose only provides very barebones cloning support in order to
  maximize flexibility.

  This role provides a clone method that makes use of the low level cloning
  support already in Moose and adds selective deep cloning based on introspection
  on top of that. Attributes with the Clone trait will handle cloning of data
  within the object, typically delegating to the attribute value's own clone
  method.


pkgId: f5da8714537ed32988522cb1e34dec136d052c56f537a2d045349a3ec4eb58b6
name: perl-MooseX-ConfigFromFile
arch: src
version: 0.03
epoch: 0
release: 4.1.1
summary: An abstract Moose role for setting attributes from a configfile
url: http://search.cpan.org/dist/MooseX-ConfigFromFile/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-ConfigFromFile-0.03-4.1.1.src.rpm
checksum_type: sha256
description:
  This is an abstract role which provides an alternate constructor for
  creating objects using parameters passed in from a configuration file. The
  actual implementation of reading the configuration file is left to concrete
  subroles.

  It declares an attribute 'configfile' and a class method 'new_with_config',
  and requires that concrete roles derived from it implement the class method
  'get_config_from_file'.

  Attributes specified directly as arguments to 'new_with_config' supercede
  those in the configfile.

  the MooseX::Getopt manpage knows about this abstract role, and will use it
  if available to load attributes from the file specified by the commandline
  flag '--configfile' during its normal 'new_with_options'.


pkgId: 8fb2e7d4bbbe3e5c6c7b9f5096fca046a6687b40836eba423c726526126f74ad
name: perl-MooseX-Daemonize
arch: src
version: 0.13
epoch: 0
release: 4.1.1
summary: Role for daemonizing your Moose based application
url: http://search.cpan.org/dist/MooseX-Daemonize/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Daemonize-0.13-4.1.1.src.rpm
checksum_type: sha256
description:
  Often you want to write a persistant daemon that has a pid file, and
  responds appropriately to Signals. This module provides a set of basic
  roles as an infrastructure to do that.


pkgId: e8ce0c2da373d4db89469b5acced9434c80ba126a963a46bf52e62076f98a2e2
name: perl-MooseX-Declare
arch: src
version: 0.35
epoch: 0
release: 4.1.1
summary: Declarative syntax for Moose
url: http://search.cpan.org/dist/MooseX-Declare/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Declare-0.35-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides syntactic sugar for Moose, the postmodern object
  system for Perl 5. When used, it sets up the 'class' and 'role' keywords.


pkgId: 9e6eb9a41f0255da6eb7720ee346bd6cf31dd79e58f1e8de2071ceadb9f2b63f
name: perl-MooseX-Getopt
arch: src
version: 0.45
epoch: 0
release: 4.1.1
summary: A Moose role for processing command line options
url: http://search.cpan.org/dist/MooseX-Getopt/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Getopt-0.45-4.1.1.src.rpm
checksum_type: sha256
description:
  This is a role which provides an alternate constructor for creating objects
  using parameters passed in from the command line.

  This module attempts to DWIM as much as possible with the command line
  params by introspecting your class's attributes. It will use the name of
  your attribute as the command line option, and if there is a type
  constraint defined, it will configure Getopt::Long to handle the option
  accordingly.

  You can use the trait the MooseX::Getopt::Meta::Attribute::Trait manpage or
  the attribute metaclass the MooseX::Getopt::Meta::Attribute manpage to get
  non-default commandline option names and aliases.

  You can use the trait the MooseX::Getopt::Meta::Attribute::Trait::NoGetopt
  manpage or the attribute metaclass the
  MooseX::Getopt::Meta::Attribute::NoGetopt manpage to have 'MooseX::Getopt'
  ignore your attribute in the commandline options.

  By default, attributes which start with an underscore are not given
  commandline argument support, unless the attribute's metaclass is set to
  the MooseX::Getopt::Meta::Attribute manpage. If you don't want your
  accessors to have the leading underscore in their name, you can do this:

    
    has '_foo' => (accessor => 'foo', ...);

    
    has '_bar' => (reader => 'bar', ...);

  This will mean that Getopt will not handle a --foo param, but your code can
  still call the 'foo' method.

  If your class also uses a configfile-loading role based on the
  MooseX::ConfigFromFile manpage, such as the MooseX::SimpleConfig manpage,
  the MooseX::Getopt manpage's 'new_with_options' will load the configfile
  specified by the '--configfile' option (or the default you've given for the
  configfile attribute) for you.

  Options specified in multiple places follow the following precedence order:
  commandline overrides configfile, which overrides explicit new_with_options
  parameters.


pkgId: 7a3e8895c2a1a09db677c10fa78261ac56be883de37ee3981318e3a1928a8156
name: perl-MooseX-GlobRef
arch: src
version: 0.0701
epoch: 0
release: 4.1.1
summary: Store a Moose object in glob reference
url: http://search.cpan.org/dist/MooseX-GlobRef/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-GlobRef-0.0701-4.1.1.src.rpm
checksum_type: sha256
description:
  This module allows to store Moose object in glob reference of file handle.
  The class attributes will be stored in hash slot associated with glob
  reference. It allows to create a Moose version of the IO::Handle manpage.

  The attributes can be accessed directly with following expression:

    my $hashref = \%{*$self};
    print $hashref->{key};

  or shorter:

    print *$self->{key};

  but the standard accessors should be used instead:

    print $self->key;


pkgId: 9cdebddfb360d3c9e0a3047b669e2159c86e0cac3e4b578a9fae00391cbfda70
name: perl-MooseX-InsideOut
arch: src
version: 0.106
epoch: 0
release: 4.1.1
summary: inside-out objects with Moose
url: http://search.cpan.org/dist/MooseX-InsideOut/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-InsideOut-0.106-4.1.1.src.rpm
checksum_type: sha256
description:
  MooseX::InsideOut provides metaroles for inside-out objects. That is, it
  sets up attribute slot storage somewhere other than inside '$self'. This
  means that you can extend non-Moose classes, whose internals you either
  don't want to care about or aren't hash-based.


pkgId: b71f72874ba87e16cabd2add380f29a1cd7eca410362139955ac71b257a3704b
name: perl-MooseX-Iterator
arch: src
version: 0.11
epoch: 0
release: 4.1.1
summary: Iterate over collections
url: http://search.cpan.org/dist/MooseX-Iterator/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Iterator-0.11-4.1.1.src.rpm
checksum_type: sha256
description:
  This is an attempt to add smalltalk-like streams to Moose. It currently
  works with ArrayRefs and HashRefs.

  * next

    The next method provides the next item in the colletion.

      For arrays it returns the element of the array

      For hashs it returns a pair as a hashref with the keys: key and value

  * has_next

    The has_next method is a boolean method that is true if there is another
    item in the colletion after the current item. and falue if there isn't.

  * peek

    The peek method returns the next item without moving the state of the
    iterator forward. It returns undef if it is at the end of the collection.

  * reset

    Resets the cursor, so you can iterate through the elements again.


pkgId: 262710ce1761f9a67499e95e354f052a05a27a1c66a205cbc30c264d9699617b
name: perl-MooseX-LazyRequire
arch: src
version: 0.07
epoch: 0
release: 4.1.1
summary: Required attributes which fail only when trying to use them
url: http://search.cpan.org/dist/MooseX-LazyRequire/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-LazyRequire-0.07-4.1.1.src.rpm
checksum_type: sha256
description:
  This module adds a 'lazy_required' option to Moose attribute declarations.

  The reader methods for all attributes with that option will throw an
  exception unless a value for the attributes was provided earlier by a
  constructor parameter or through a writer method.


pkgId: 6e5e1b599324c333019ae43bde2b79da5812e4103abf6912d6da84bc12943730
name: perl-MooseX-Log-Log4perl
arch: src
version: 0.43
epoch: 0
release: 4.1.1
summary: A Logging Role for Moose based on Log::Log4perl
url: http://search.cpan.org/dist/MooseX-Log-Log4perl/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build34
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Log-Log4perl-0.43-4.1.1.src.rpm
checksum_type: sha256
description:
  A logging role building a very lightweight wrapper to the Log::Log4perl
  manpage for use with your the Moose manpage classes. The initialization of
  the Log4perl instance must be performed prior to logging the first log
  message. Otherwise the default initialization will happen, probably not
  doing the things you expect.

  For compatibility the 'logger' attribute can be accessed to use a common
  interface for application logging.

  Using the logger within a class is as simple as consuming a role:

      package MyClass;
      use Moose;
      with 'MooseX::Log::Log4perl';

      sub dummy {
          my $self = shift;
          $self->log->info("Dummy log entry");
      }

  The logger needs to be setup before using the logger, which could happen in
  the main application:

      package main;
      use Log::Log4perl qw(:easy);
      use MyClass;

      BEGIN { Log::Log4perl->easy_init() };

      my $myclass = MyClass->new();
      $myclass->log->info("In my class"); # Access the log of the object
      $myclass->dummy;                    # Will log "Dummy log entry"


pkgId: 429c413f1df4ebe225e226521c5218ecd3ee1c981765d43af432c9a7947032e0
name: perl-MooseX-Meta-TypeConstraint-ForceCoercion
arch: src
version: 0.01
epoch: 0
release: 4.1.1
summary: Force coercion when validating type constraints
url: http://search.cpan.org/dist/MooseX-Meta-TypeConstraint-ForceCoercion
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build40
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Meta-TypeConstraint-ForceCoercion-0.01-4.1.1.src.rpm
checksum_type: sha256
description:
  This class allows to wrap any "Moose::Meta::TypeConstraint" in a way that
  will force coercion of the value when checking or validating a value
  against it.


pkgId: 52729935031638f9d35251b8f2891ed73c9797fb382ba4caee7b758733401127
name: perl-MooseX-Method-Signatures
arch: src
version: 0.43
epoch: 0
release: 4.1.1
summary: Method declarations with type constraints and no source filter
url: http://search.cpan.org/dist/MooseX-Method-Signatures/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build08
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Method-Signatures-0.43-4.1.1.src.rpm
checksum_type: sha256
description:
  Provides a proper method keyword, like "sub" but specifically for making
  methods and validating their arguments against Moose type constraints.


pkgId: a13e582303af0f5e7fdf5ee092cc4e3443ddd01806e9f912a64ec58dfa1ebdff
name: perl-MooseX-MultiInitArg
arch: src
version: 0.01
epoch: 0
release: 8.1.1
summary: Attributes with aliases for constructor arguments.
url: http://search.cpan.org/dist/MooseX-MultiInitArg/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-MultiInitArg-0.01-8.1.1.src.rpm
checksum_type: sha256
description:
  If you've ever wanted to be able to call an attribute any number of things
  while you're passing arguments to your object constructor, Now You Can.

  The primary motivator is that I have some attributes that were named
  inconsistently, and I wanted to rename them without breaking backwards
  compatibility with my existing API.


pkgId: d3a87678932b05bc36d52fe69c2fd63e6bf7803dfe733c48827244fa1e86f7f1
name: perl-MooseX-NonMoose
arch: src
version: 0.22
epoch: 0
release: 4.1.1
summary: easy subclassing of non-Moose classes
url: http://search.cpan.org/dist/MooseX-NonMoose/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-NonMoose-0.22-4.1.1.src.rpm
checksum_type: sha256
description:
  'MooseX::NonMoose' allows for easily subclassing non-Moose classes with
  Moose, taking care of the annoying details connected with doing this, such
  as setting up proper inheritance from the Moose::Object manpage and
  installing (and inlining, at 'make_immutable' time) a constructor that
  makes sure things like 'BUILD' methods are called. It tries to be as
  non-intrusive as possible - when this module is used, inheriting from
  non-Moose classes and inheriting from Moose classes should work
  identically, aside from the few caveats mentioned below. One of the goals
  of this module is that including it in a the Moose::Exporter manpage-based
  package used across an entire application should be possible, without
  interfering with classes that only inherit from Moose modules, or even
  classes that don't inherit from anything at all.

  There are several ways to use this module. The most straightforward is to
  just 'use MooseX::NonMoose;' in your class; this should set up everything
  necessary for extending non-Moose modules. the
  MooseX::NonMoose::Meta::Role::Class manpage and the
  MooseX::NonMoose::Meta::Role::Constructor manpage can also be applied to
  your metaclasses manually, either by passing a '-traits' option to your
  'use Moose;' line, or by applying them using the Moose::Util::MetaRole
  manpage in a the Moose::Exporter manpage-based package. the
  MooseX::NonMoose::Meta::Role::Class manpage is the part that provides the
  main functionality of this module; if you don't care about inlining, this
  is all you need to worry about. Applying the
  MooseX::NonMoose::Meta::Role::Constructor manpage as well will provide an
  inlined constructor when you immutabilize your class.

  'MooseX::NonMoose' allows you to manipulate the argument list that gets
  passed to the superclass constructor by defining a 'FOREIGNBUILDARGS'
  method. This is called with the same argument list as the 'BUILDARGS'
  method, but should return a list of arguments to pass to the superclass
  constructor. This allows 'MooseX::NonMoose' to support superclasses whose
  constructors would get confused by the extra arguments that Moose requires
  (for attributes, etc.)

  Not all non-Moose classes use 'new' as the name of their constructor. This
  module allows you to extend these classes by explicitly stating which
  method is the constructor, during the call to 'extends'. The syntax looks
  like this:

    extends 'Foo' => { -constructor_name => 'create' };

  similar to how you can already pass '-version' in the 'extends' call in a
  similar way.


pkgId: 048c8e002fdc24ccfe9398e0117bd6d2dddc6239c2e98d41f1f75ba0ae016e51
name: perl-MooseX-Object-Pluggable
arch: src
version: 0.0011
epoch: 0
release: 4.1.1
summary: Make your classes pluggable
url: http://search.cpan.org/dist/MooseX-Object-Pluggable/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Object-Pluggable-0.0011-4.1.1.src.rpm
checksum_type: sha256
description:
  This module is meant to be loaded as a role from Moose-based classes it
  will add five methods and four attributes to assist you with the loading
  and handling of plugins and extensions for plugins. I understand that this
  may pollute your namespace, however I took great care in using the least
  ambiguous names possible.


pkgId: e1b8afebd06fa78e04df451f442cd1102741815fcf9cffeb345d9ca6e3520622
name: perl-MooseX-OneArgNew
arch: src
version: 0.002
epoch: 0
release: 4.1.1
summary: teach ->new to accept single, non-hashref arguments
url: http://search.cpan.org/dist/MooseX-OneArgNew/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-OneArgNew-0.002-4.1.1.src.rpm
checksum_type: sha256
description:
  MooseX::OneArgNew lets your constructor take a single argument, which will
  be translated into the value for a one-entry hashref. It is a the
  parameterized role|MooseX::Role::Parameterized manpage with two parameters:

  * type

    The Moose type that the single argument must be for the one-arg form to
    work. This should be an existing type, and may be either a string type or
    a MooseX::Type.

  * init_arg

    This is the string that will be used as the key for the hashref
    constructed from the one-arg call to new.


pkgId: 63725d713d5bef07d826570c005dd3cf18100380c9c24e8859af3834d0b4cfc5
name: perl-MooseX-Param
arch: src
version: 0.02
epoch: 0
release: 4.1.1
summary: Simple role to provide a standard param method
url: http://search.cpan.org/dist/MooseX-Param/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Param-0.02-4.1.1.src.rpm
checksum_type: sha256
description:
  This is a very simple Moose role which provides a the CGI manpage like
  'param' method.

  I found that I had written this code over and over and over and over again,
  and each time it was the same. So I thought, why not put it in a role?


pkgId: 52e6a17b122765791e2b3bed488000dbcd396425f76d02eb9ddeb1dad7fa6d08
name: perl-MooseX-Params-Validate
arch: src
version: 0.16
epoch: 0
release: 4.1.1
summary: an extension of Params::Validate using Moose's types
url: http://search.cpan.org/dist/MooseX-Params-Validate/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Params-Validate-0.16-4.1.1.src.rpm
checksum_type: sha256
description:
  This module fills a gap in Moose by adding method parameter validation to
  Moose. This is just one of many developing options, it should not be
  considered the "official" one by any means though.

  You might also want to explore 'MooseX::Method::Signatures' and
  'MooseX::Declare'.


pkgId: 546fede200a8a3422138d6ca090bc94aefd9498c47084169d8620d576f6fe5ba
name: perl-MooseX-Role-Cmd
arch: src
version: 0.10
epoch: 0
release: 5.1.1
summary: Wrap system command binaries the Moose way
url: http://search.cpan.org/dist/MooseX-Role-Cmd/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Role-Cmd-0.10-5.1.1.src.rpm
checksum_type: sha256
description:
  MooseX::Role::Cmd is a the Moose manpage role intended to ease the task of
  building command-line wrapper modules. It automatically maps the Moose
  manpage objects into command strings which are passed to the IPC::Cmd
  manpage.


pkgId: 3cf1318db8685611a4a1714e8c048e1ef6f60392942cbb46cfe0172b2b074b8d
name: perl-MooseX-Role-Parameterized
arch: src
version: 1.00
epoch: 0
release: 4.1.1
summary: Roles with composition parameters
url: http://search.cpan.org/dist/MooseX-Role-Parameterized/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Role-Parameterized-1.00-4.1.1.src.rpm
checksum_type: sha256
description:
  Your parameterized role consists of two new things: parameter declarations
  and a 'role' block.

  Parameters are declared using the the /parameter manpage keyword which very
  much resembles the Moose/has manpage. You can use any option that the
  Moose/has manpage accepts. The default value for the 'is' option is 'ro' as
  that's a very common case. Use 'is => 'bare'' if you want no accessor.
  These parameters will get their values when the consuming class (or role)
  uses the Moose/with manpage. A parameter object will be constructed with
  these values, and passed to the 'role' block.

  The 'role' block then uses the usual the Moose::Role manpage keywords to
  build up a role. You can shift off the parameter object to inspect what the
  consuming class provided as parameters. You use the parameters to customize
  your role however you wish.

  There are many possible implementations for parameterized roles (hopefully
  with a consistent enough API); I believe this to be the easiest and most
  flexible design. Coincidentally, Pugs originally had an eerily similar
  design.

  See the MooseX::Role::Parameterized::Extending manpage for some tips on how
  to extend this module.


pkgId: de5b84179842ba2e2f5657b49aa709913aa3132bfddf39635694bb20e444229e
name: perl-MooseX-Role-TraitConstructor
arch: src
version: 0.01
epoch: 0
release: 4.1.1
summary: A wrapper for C<new> that can accept a
url: http://search.cpan.org/dist/MooseX-Role-TraitConstructor/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Role-TraitConstructor-0.01-4.1.1.src.rpm
checksum_type: sha256
description:
  This role allows you to easily accept a 'traits' argument (or another name)
  into your constructor, which will easily mix roles into an anonymous class
  before construction, much like the Moose::Meta::Attribute manpage does.


pkgId: a47e0fa1e856a02d5733c751dcecc9dae865b9aaac7aa9c34f4f8188d8e94f34
name: perl-MooseX-SemiAffordanceAccessor
arch: src
version: 0.09
epoch: 0
release: 4.1.1
summary: Name your accessors foo() and set_foo()
url: http://search.cpan.org/dist/MooseX-SemiAffordanceAccessor/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build19
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-SemiAffordanceAccessor-0.09-4.1.1.src.rpm
checksum_type: sha256
description:
  This module does not provide any methods. Simply loading it changes the
  default naming policy for the loading class so that accessors are separated
  into get and set methods. The get methods have the same name as the
  accessor, while set methods are prefixed with "set_".

  If you define an attribute with a leading underscore, then the set method
  will start with "_set_".

  If you explicitly set a "reader" or "writer" name when creating an
  attribute, then that attribute's naming scheme is left unchanged.

  The name "semi-affordance" comes from David Wheeler's Class::Meta module.


pkgId: 2149abb4b3abf8870b22003932293d085ea43bb6d85ad07d7d6a01d08fab39ee
name: perl-MooseX-SetOnce
arch: src
version: 0.200001
epoch: 0
release: 4.1.1
summary: write-once, read-many attributes for Moose
url: http://search.cpan.org/dist/MooseX-SetOnce/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-SetOnce-0.200001-4.1.1.src.rpm
checksum_type: sha256
description:
  The 'SetOnce' attribute lets your class have attributes that are not lazy
  and not set, but that cannot be altered once set.

  The logic is very simple: if you try to alter the value of an attribute
  with the SetOnce trait, either by accessor or writer, and the attribute has
  a value, it will throw an exception.

  If the attribute has a clearer, you may clear the attribute and set it
  again.


pkgId: f105f96d7c9d2282f34a6892c7eae09ea39f1da592c4419ab12b5a7ec912c2fb
name: perl-MooseX-SimpleConfig
arch: src
version: 0.09
epoch: 0
release: 4.1.1
summary: A Moose role for setting attributes from a simple configfile
url: http://search.cpan.org/dist/MooseX-SimpleConfig
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build09
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-SimpleConfig-0.09-4.1.1.src.rpm
checksum_type: sha256
description:
  This role loads simple configfiles to set object attributes. It is based
  on the abstract role MooseX::ConfigFromFile, and uses Config::Any to load
  your configfile. Config::Any will in turn support any of a variety of
  different config formats, detected by the file extension. See Config::Any
  for more details about supported formats.
  Like all MooseX::ConfigFromFile -derived configfile loaders, this module
  is automatically supported by the MooseX::Getopt role as well, which
  allows specifying "-configfile" on the commandline.


pkgId: ac43ebdd45beff631e8a7fa057285c113253563df29937f1fe0e9caaee0f0d6a
name: perl-MooseX-Singleton
arch: src
version: 0.29
epoch: 0
release: 4.1.1
summary: turn your Moose class into a singleton
url: http://search.cpan.org/dist/MooseX-Singleton/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Singleton-0.29-4.1.1.src.rpm
checksum_type: sha256
description:
  A singleton is a class that has only one instance in an application.
  'MooseX::Singleton' lets you easily upgrade (or downgrade, as it were) your
  the Moose manpage class to a singleton.

  All you should need to do to transform your class is to change 'use Moose'
  to 'use MooseX::Singleton'. This module uses metaclass roles to do its
  magic, so it should cooperate with most other 'MooseX' modules.


pkgId: b206e28d007d63e0991a22a3121dbd79f6b8affd79e96485c21d1d4204ed2498
name: perl-MooseX-Storage
arch: src
version: 0.30
epoch: 0
release: 4.1.1
summary: A serialization framework for Moose classes
url: http://search.cpan.org/dist/MooseX-Storage/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Storage-0.30-4.1.1.src.rpm
checksum_type: sha256
description:
  MooseX::Storage is a serialization framework for Moose, it provides a very
  flexible and highly pluggable way to serialize Moose classes to a number of
  different formats and styles.


pkgId: fd3ac6252074f9c7aa5845ef7aa8d56d6cd880494039211524df7826dc36102c
name: perl-MooseX-StrictConstructor
arch: src
version: 0.16
epoch: 0
release: 4.1.1
summary: Make your object constructors blow up on unknown attributes
url: http://search.cpan.org/dist/MooseX-StrictConstructor/
rpm_license: Artistic-2.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build04
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-StrictConstructor-0.16-4.1.1.src.rpm
checksum_type: sha256
description:
  Simply loading this module makes your constructors "strict". If your
  constructor is called with an attribute init argument that your class does
  not declare, then it calls 'Moose-'throw_error()>. This is a great way to
  catch small typos.


pkgId: f46ccf61c531c7a76db4cf79279c0b2589e5115726e533e627dd6fbfdf804ca3
name: perl-MooseX-Traits
arch: src
version: 0.11
epoch: 0
release: 4.1.1
summary: automatically apply roles at object creation time
url: http://search.cpan.org/dist/MooseX-Traits/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Traits-0.11-4.1.1.src.rpm
checksum_type: sha256
description:
  Often you want to create components that can be added to a class
  arbitrarily. This module makes it easy for the end user to use these
  components. Instead of requiring the user to create a named class with the
  desired roles applied, or apply roles to the instance one-by-one, he can
  just create a new class from yours with 'with_traits', and then instantiate
  that.

  There is also 'new_with_traits', which exists for compatibility reasons. It
  accepts a 'traits' parameter, creates a new class with those traits, and
  then insantiates it.

     Class->new_with_traits( traits => [qw/Foo Bar/], foo => 42, bar => 1 )

  returns exactly the same object as

     Class->with_traits(qw/Foo Bar/)->new( foo => 42, bar => 1 )

  would. But you can also store the result of 'with_traits', and call other
  methods:

     my $c = Class->with_traits(qw/Foo Bar/);
     $c->new( foo => 42 );
     $c->whatever( foo => 1234 );

  And so on.


pkgId: 2a13514100e7549fd316b8921e30e705cb3378df4660a6f041e1af8e81260797
name: perl-MooseX-Types
arch: src
version: 0.35
epoch: 0
release: 4.1.1
summary: Organise your Moose types in libraries
url: http://search.cpan.org/dist/MooseX-Types/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build22
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-0.35-4.1.1.src.rpm
checksum_type: sha256
description:
  The type system provided by Moose effectively makes all of its builtin type
  global, as are any types you declare with Moose. This means that every
  module that declares a type named "PositiveInt" is sharing the same type
  object. This can be a problem when different parts of the code base want to
  use the same name for different things.

  This package lets you declare types using short names, but behind the
  scenes it namespaces all your type declarations, effectively prevent name
  clashes between packages.

  This is done by creating a type library module like 'MyApp::Types' and then
  importing types from that module into other modules.

  As a side effect, the declaration mechanism allows you to write type names
  as barewords (really function calls), which catches typos in names at
  compile time rather than run time.

  This module also provides some helper functions for using Moose types
  outside of attribute declarations.

  If you mix string-based names with types created by this module, it will
  warn, with a few exceptions. If you are declaring a 'class_type()' or
  'role_type()' within your type library, or if you use a fully qualified
  name like '"MyApp::Foo"'.


pkgId: fa41aee41836eef85010da6b31f0ee9b3b7cb43a7fd44a55455e7b7df3fad922
name: perl-MooseX-Types-DateTime
arch: src
version: 0.07
epoch: 0
release: 4.1.1
summary: DateTime related constraints and coercions for
url: http://search.cpan.org/dist/MooseX-Types-DateTime/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-DateTime-0.07-4.1.1.src.rpm
checksum_type: sha256
description:
  This module packages several the Moose::Util::TypeConstraints manpage with
  coercions, designed to work with the the DateTime manpage suite of objects.


pkgId: 3366f7bde3093c29d5c94bae12fda23368b0ac7397b990c256607087fa9f15da
name: perl-MooseX-Types-LoadableClass
arch: src
version: 0.007
epoch: 0
release: 4.1.1
summary: ClassName type constraint with coercion to load the class.
url: http://search.cpan.org/dist/MooseX-Types-LoadableClass/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build06
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-LoadableClass-0.007-4.1.1.src.rpm
checksum_type: sha256
description:
      use Moose::Util::TypeConstraints;

      my $tc = subtype as ClassName;
      coerce $tc, from Str, via { Class::MOP::load_class($_); $_ };

  I've written those three lines of code quite a lot of times, in quite a lot
  of places.

  Now I don't have to.


pkgId: 43c74b0c305da9af032f5b39c5a6aa1b294acf109a09fb2114b717b59b0d46b0
name: perl-MooseX-Types-Parameterizable
arch: src
version: 0.08
epoch: 0
release: 4.1.1
summary: Create your own Parameterizable Types.
url: http://search.cpan.org/dist/MooseX-Types-Parameterizable/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-Parameterizable-0.08-4.1.1.src.rpm
checksum_type: sha256
description:
  A the MooseX::Types manpage library for creating parameterizable types. A
  parameterizable type constraint for all intents and uses is a subclass of a
  parent type, but adds additional type parameters which are available to
  constraint callbacks (such as inside the 'where' clause of a type
  constraint definition) or in the coercions you define for a given type
  constraint.

  If you have the Moose manpage experience, you probably are familiar with
  the builtin parameterizable type constraints 'ArrayRef' and 'HashRef'. This
  type constraint lets you generate your own versions of parameterized
  constraints that work similarly. See the Moose::Util::TypeConstraints
  manpage for more.


pkgId: 6e700fb3a44db4ed016bc794df4be830920b986153c035702c58625834ddd59b
name: perl-MooseX-Types-Path-Class
arch: src
version: 0.05
epoch: 0
release: 4.1.1
summary: A Path::Class type library for Moose
url: http://search.cpan.org/dist/MooseX-Types-Path-Class/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build05
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-Path-Class-0.05-4.1.1.src.rpm
checksum_type: sha256
description:
  MooseX::Types::Path::Class creates common the Moose manpage types,
  coercions and option specifications useful for dealing with the Path::Class
  manpage objects as the Moose manpage attributes.

  Coercions (see the Moose::Util::TypeConstraints manpage) are made from both
  'Str' and 'ArrayRef' to both the Path::Class::Dir manpage and the
  Path::Class::File manpage objects. If you have the MooseX::Getopt manpage
  installed, the Getopt option type ("=s") will be added for both the
  Path::Class::Dir manpage and the Path::Class::File manpage.


pkgId: 8e81061cc692b44b9c60b5a4abdfa8aed47658323fc066feb4c508641dda9e5a
name: perl-MooseX-Types-Perl
arch: src
version: 0.101341
epoch: 0
release: 4.1.1
summary: Moose types that check against Perl syntax
url: http://search.cpan.org/dist/MooseX-Types-Perl/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build27
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-Perl-0.101341-4.1.1.src.rpm
checksum_type: sha256
description:
  This library provides MooseX::Types for checking things (mostly strings)
  against syntax that is, or is a reasonable subset of, Perl syntax.


pkgId: 8c39ccb817926399cb7fda6786364a27bcd9e9fc1da8fa09f8c00db5c347842d
name: perl-MooseX-Types-Set-Object
arch: src
version: 0.03
epoch: 0
release: 4.1.1
summary: Set::Object type with coercions and stuff.
url: http://search.cpan.org/dist/MooseX-Types-Set-Object/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build23
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-Set-Object-0.03-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides Moose type constraints (see the
  Moose::Util::TypeConstraints manpage, the MooseX::Types manpage).


pkgId: 81ca182b6ffd6f01164eb5bfdf0cafb6c687a030151a877d26611603d25ecf71
name: perl-MooseX-Types-Structured
arch: src
version: 0.28
epoch: 0
release: 4.1.1
summary: Structured Type Constraints for Moose
url: http://search.cpan.org/dist/MooseX-Types-Structured
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build35
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Types-Structured-0.28-4.1.1.src.rpm
checksum_type: sha256
description:
  A structured type constraint is a standard container Moose type
  constraint, such as an ArrayRef or HashRef, which has been enhanced to
  allow you to explicitly name all the allowed type constraints inside the
  structure.

  This type library enables structured type constraints. It is built on top
  of the MooseX::Types library system, so you should review the
  documentation for that if you are not familiar with it.


pkgId: a9a11aa53c12fdf581e8759c2755353a8700eba55784b7590585e987c121ee7b
name: perl-MooseX-Workers
arch: src
version: 0.16
epoch: 0
release: 4.1.1
summary: Simple sub-process management for asynchronous tasks
url: http://search.cpan.org/dist/MooseX-Workers/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build31
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-MooseX-Workers-0.16-4.1.1.src.rpm
checksum_type: sha256
description:
  MooseX::Workers is a Role that provides easy delegation of long-running
  tasks into a managed child process. Process management is taken care of via
  POE and its POE::Wheel::Run module.


pkgId: 30ab0b9061dfce8977bebd40b01edc4b90d441ad21d98961fb64643bf02e5a59
name: perl-Mouse
arch: src
version: 0.97
epoch: 0
release: 5.1.1
summary: Moose minus the antlers
url: http://search.cpan.org/dist/Mouse
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Mouse-0.97-5.1.1.src.rpm
checksum_type: sha256
description:
  This module provides some useful test functions for Mouse based classes.
  It is an experimental first release, so comments and suggestions are very
  welcome.


pkgId: 33573a422ddb493904a6f43aacff5a16f1007a09b4df6612e69b614d39e5d1b3
name: perl-Nagios-Plugin
arch: src
version: 0.36
epoch: 0
release: 2.1.1
summary: A family of perl modules to streamline writing Nagios plugins
url: http://www.perl.org/
rpm_license: Artistic-1.0 and GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Languages/Perl
rpm_buildhost: build24
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Nagios-Plugin-0.36-2.1.1.src.rpm
checksum_type: sha256
description:
  Nagios::Plugin and its associated Nagios::Plugin::* modules are a family of
  perl modules to streamline writing Nagios plugins. The main end user modules
  are Nagios::Plugin, providing an object-oriented interface to the entire
  Nagios::Plugin::* collection, and Nagios::Plugin::Functions, providing a
  simpler functional interface to a useful subset of the available functionality.

  The purpose of the collection is to make it as simple as possible for
  developers to create plugins that conform the Nagios Plugin guidelines
  (http://nagiosplug.sourceforge.net/developer-guidelines.html).


pkgId: b7998b4840872483296f240ac4d65bbcd16ba11cf3004c724dd0ada34135241a
name: perl-Net-CIDR-Lite
arch: src
version: 0.21
epoch: 0
release: 14.1.1
summary: Perl extension for merging IPv4 or IPv6 CIDR addresses
url: http://search.cpan.org/dist/Net-CIDR-Lite
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build13
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-CIDR-Lite-0.21-14.1.1.src.rpm
checksum_type: sha256
description:
  Faster alternative to Net::CIDR when merging a large number of CIDR
  address ranges. Works for IPv4 and IPv6 addresses.


  Authors:
  --------
      Douglas Wilson <dougw@cpan.org>


pkgId: 90f1e21750b75d7a9cb54e46e734ad498bc629e064bc4abcc443729777044f39
name: perl-Net-CIDR-Set
arch: src
version: 0.11
epoch: 0
release: 4.1.1
summary: Manipulate sets of IP addresses
url: http://search.cpan.org/dist/Net-CIDR-Set/
rpm_license: GPL-1.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build21
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-CIDR-Set-0.11-4.1.1.src.rpm
checksum_type: sha256
description:
  'Net::CIDR::Set' represents sets of IP addresses and allows standard set
  operations (union, intersection, membership test etc) to be performed on
  them.

  In spite of the name it can work with sets consisting of arbitrary ranges
  of IP addresses - not just CIDR blocks.

  Both IPv4 and IPv6 addresses are handled - but they may not be mixed in the
  same set. You may explicitly set the personality of a set:

    my $ip4set = Net::CIDR::Set->new({ type => 'ipv4 }, '10.0.0.0/8');

  Normally this isn't necessary - the set will guess its personality from the
  first data that is added to it.


pkgId: 1e1febcf68b7b88d928ec837246ee9ed10bc00114cd0850ac7a3a434bf96a721
name: perl-Net-DBus
arch: src
version: 1.0.0
epoch: 0
release: 5.1.1
summary: Perl extension for the DBus message system
url: http://search.cpan.org/dist/Net-DBus/
rpm_license: GPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build01
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-DBus-1.0.0-5.1.1.src.rpm
checksum_type: sha256
description:
  Net::DBus provides a Perl API for the DBus message system. The DBus Perl
  interface is currently operating against the 0.32 development version of
  DBus, but should work with later versions too, providing the API changes
  have not been too drastic.

  Users of this package are either typically, service providers in which case
  the the Net::DBus::Service manpage and the Net::DBus::Object manpage
  modules are of most relevance, or are client consumers, in which case the
  Net::DBus::RemoteService manpage and the Net::DBus::RemoteObject manpage
  are of most relevance.


pkgId: a115b7c5b5a1c4390d615f79a7ca1b06ec40792dd5dcf3f30fad81286ee9b341
name: perl-Net-DNS
arch: src
version: 0.68
epoch: 0
release: 5.1.1
summary: Perl interface to the DNS resolver
url: http://cpan.org/modules/by-module/Net/
rpm_license: GPL-2.0+ or Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build14
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-DNS-0.68-5.1.1.src.rpm
checksum_type: sha256
description:
  Net::DNS is a Perl interface to the DNS resolver.  It allows the
  programmer to perform any type of DNS query from a Perl script. For
  details and examples, please read the Net::DNS manual page.


pkgId: 1c193c114081bd2ee774a3456cf153b265b7b99934224c54918c18d98f080139
name: perl-Net-DNS-Resolver-Programmable
arch: src
version: 0.003
epoch: 0
release: 14.1.1
summary: Programmable DNS resolver class for offline emulation of DNS
url: http://search.cpan.org/dist/Net-DNS-Resolver-Programmable
rpm_license: Artistic-1.0
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build15
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-DNS-Resolver-Programmable-0.003-14.1.1.src.rpm
checksum_type: sha256
description:
  Net::DNS::Resolver::Programmable is a Net::DNS::Resolver descendant class that
  allows a virtual DNS to be emulated instead of querying the real DNS.  A set of
  static DNS records may be supplied, or arbitrary code may be specified as a
  means for retrieving DNS records, or even generating them on the fly.


  Authors:
  --------
      Julian Mehnle


pkgId: 31d3ea4ec9d7c512ec7f209185a6790ead0603f9b1f90caa673db96bca8085f2
name: perl-Net-Daemon
arch: src
version: 0.48
epoch: 0
release: 8.1.1
summary: Perl extension for portable daemons
url: http://search.cpan.org/dist/Net-Daemon/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build10
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-Daemon-0.48-8.1.1.src.rpm
checksum_type: sha256
description:
  Net::Daemon is an abstract base class for implementing portable server
  applications in a very simple way. The module is designed for Perl 5.005
  and threads, but can work with fork() and Perl 5.004.

  The Net::Daemon class offers methods for the most common tasks a daemon
  needs: Starting up, logging, accepting clients, authorization, restricting
  its own environment for security and doing the true work. You only have to
  override those methods that aren't appropriate for you, but typically
  inheriting will safe you a lot of work anyways.


pkgId: 5974b649b5bb9b2c377a2306c8b61c14590d6d9521d2b714d73a5092c416f0a4
name: perl-Net-HTTP
arch: src
version: 6.03
epoch: 0
release: 4.1.1
summary: Low-level HTTP connection (client)
url: http://search.cpan.org/dist/Net-HTTP/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build34
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-HTTP-6.03-4.1.1.src.rpm
checksum_type: sha256
description:
  The 'Net::HTTP' class is a low-level HTTP client. An instance of the
  'Net::HTTP' class represents a connection to an HTTP server. The HTTP
  protocol is described in RFC 2616. The 'Net::HTTP' class supports
  'HTTP/1.0' and 'HTTP/1.1'.

  'Net::HTTP' is a sub-class of 'IO::Socket::INET'. You can mix the methods
  described below with reading and writing from the socket directly. This is
  not necessary a good idea, unless you know what you are doing.


pkgId: 7da9435534bf2250276611e00177e75f114ad44482b7a88df2a6a1999276a6fe
name: perl-Net-HTTPServer
arch: src
version: 1.1.1
epoch: 0
release: 22.1.1
summary: A simple perl Http Server
url: http://search.cpan.org/dist/Net-HTTPServer/
rpm_license: LGPL-2.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build32
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-HTTPServer-1.1.1-22.1.1.src.rpm
checksum_type: sha256
description:
  Net::HTTPServer basically turns a CGI script into a stand alone server.
  Useful for temporary services, mobile/local servers, or embedding an HTTP
  server into another program.


pkgId: 8f1fc015ce505049bf914e576effa2d91909b5c3a8bb3f3f0f58cd3614d791d5
name: perl-Net-IDN-Encode
arch: src
version: 1.100
epoch: 0
release: 4.1.1
summary: Internationalizing Domain Names in Applications (RFC 3490)
url: http://search.cpan.org/dist/Net-IDN-Encode/
rpm_license: Artistic-1.0 or GPL-1.0+
rpm_vendor: openSUSE
rpm_group: Development/Libraries/Perl
rpm_buildhost: build20
rpm_packager: http://bugs.opensuse.org
location_href: src/perl-Net-IDN-Encode-1.100-4.1.1.src.rpm
checksum_type: sha256
description:
  This module provides an easy-to-use interface for encoding and decoding
  Internationalized Domain Names (IDNs).

  IDNs use characters drawn from a large repertoire (Unicode), but IDNA allows
  the non-ASCII characters to be represented using only the ASCII characters
  already allowed in so-called host names today (letter-digit-hypen,
  /[A-Z0-9-]/i).


