# packages

pkgId: d8eab1619dac8a724af85065ab25d102728e5da3e9fc34539fe92bf9cf90bded
name: local-perl-Tie-ToObject
arch: noarch
version: 0.03
epoch: 0
release: 1
summary: Tie-ToObject - Tie to an existing object.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yuval Kogman <Eltnothingmuch@woobling.orgEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Tie-ToObject-0.03-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Tie-ToObject-0.03-1.noarch.rpm
checksum_type: sha256
description:
  While L<perldoc/tie> allows tying to an arbitrary object, the class in question
  must support this in it's implementation of C<TIEHASH>, C<TIEARRAY> or
  whatever.

  This class provides a very tie constructor that simply returns the object it
  was given as it's first argument.

  This way side effects of calling C<< $object->TIEHASH >> are avoided.

  This is used in L<Data::Visitor> in order to tie a variable to an already
  existing object. This is also useful for cloning, when you want to clone the
  internal state object instead of going through the tie interface for that
  variable.


pkgId: 76fe99a6cdda7b5fc98f73cc0df1fb3207009ea678ddf55a07feaae957964bf2
name: local-perl-Tie-Watch
arch: noarch
version: 1.301
epoch: 0
release: 1
summary: Tie-Watch - Place watchpoints on Perl (and Tk) variables
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Steve Lidie (Stephen.O.Lidie@Lehigh.EDU)
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Tie-Watch-1.301-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Tie-Watch-1.301-1.noarch.rpm
checksum_type: sha256
description:
  This class module binds one or more subroutines of your devising to a
  Perl variable.  All variables can have B<FETCH>, B<STORE> and
  B<DESTROY> callbacks.  Additionally, arrays can define B<CLEAR>,
  B<DELETE>, B<EXISTS>, B<EXTEND>, B<FETCHSIZE>, B<POP>, B<PUSH>,
  B<SHIFT>, B<SPLICE>, B<STORESIZE> and B<UNSHIFT> callbacks, and hashes
  can define B<CLEAR>, B<DELETE>, B<EXISTS>, B<FIRSTKEY> and B<NEXTKEY>
  callbacks.  If these term are unfamiliar to you, I I<really> suggest
  you read L<perltie>.

  With Tie::Watch you can:

   . alter a variable's value
   . prevent a variable's value from being changed
   . invoke a Perl/Tk callback when a variable changes
   . trace references to a variable

  Callback format is patterned after the Perl/Tk scheme: supply either a
  code reference, or, supply an array reference and pass the callback
  code reference in the first element of the array, followed by callback
  arguments.  (See examples in the Synopsis, above.)

  Tie::Watch provides default callbacks for any that you fail to
  specify.  Other than negatively impacting performance, they perform
  the standard action that you'd expect, so the variable behaves
  "normally".  Once you override a default callback, perhaps to insert
  debug code like print statements, your callback normally finishes by
  calling the underlying (overridden) method.  But you don't have to!

  To map a tied method name to a default callback name simply lowercase
  the tied method name and uppercase its first character.  So FETCH
  becomes Fetch, NEXTKEY becomes Nextkey, etcetera.

  Here are two callbacks for a scalar. The B<FETCH> (read) callback does
  nothing other than illustrate the fact that it returns the value to
  assign the variable.  The B<STORE> (write) callback uppercases the
  variable and returns it.  In all cases the callback I<must> return the
  correct read or write value - typically, it does this by invoking the
  underlying method.

   my $fetch_scalar = sub {
       my($self) = @_;
       $self->Fetch;
   };

   my $store_scalar = sub {
       my($self, $new_val) = @_;
       $self->Store(uc $new_val);
   };

  Here are B<FETCH> and B<STORE> callbacks for either an array or hash.
  They do essentially the same thing as the scalar callbacks, but
  provide a little more information.

   my $fetch = sub {
       my($self, $key) = @_;
       my $val = $self->Fetch($key);
       print "In fetch callback, key=$key, val=", $self->Say($val);
       my $args = $self->Args(-fetch);
       print ", args=('", join("', '",  @$args), "')" if $args;
       print ".\n";
       $val;
   };

   my $store = sub {
       my($self, $key, $new_val) = @_;
       my $val = $self->Fetch($key);
       $new_val = uc $new_val;
       $self->Store($key, $new_val);
       print "In store callback, key=$key, val=", $self->Say($val),
         ", new_val=", $self->Say($new_val);
       my $args = $self->Args(-store);
       print ", args=('", join("', '",  @$args), "')" if $args;
       print ".\n";
       $new_val;
   };

  In all cases, the first parameter is a reference to the Watch object,
  used to invoke the following class methods.


pkgId: e8793aee1940eeded2d59088c1796c1f228015d1510bbc2d706d1080e0198be5
name: local-perl-Time-Piece
arch: x86_64
version: 1.20_01
epoch: 0
release: 162.ep
summary: Time objects from localtime and gmtime
url: http://www.perl.org/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-5.14.1-162.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-Time-Piece-1.20_01-162.ep.x86_64.rpm
checksum_type: sha256
description:
  The Time::Piece module replaces the standard localtime and gmtime functions
  with implementations that return objects.  It does so in a backwards compatible
  manner, so that using localtime or gmtime as documented in perlfunc still
  behave as expected.


pkgId: 87a0e47ad9bbc8400f594d1cc3d9c2c5570d3e65b0e0bea45573bb01404f865b
name: local-perl-Time-modules
arch: noarch
version: 2011.0517
epoch: 0
release: 1
summary: Time-modules - Parse and format time values
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Muir Sharnoff <cpan@dave.sharnoff.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Time-modules-2011.0517-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Time-modules-2011.0517-1.noarch.rpm
checksum_type: sha256
description:
  This module recognizes the above date/time formats.   Usually a
  date and a time are specified.  There are numerous options for
  controlling what is recognized and what is not.

  The return code is always the time in seconds since January 1st, 1970
  or undef if it was unable to parse the time.

  If a timezone is specified it must be after the time.  Year specifications
  can be tacked onto the end of absolute times.

  If C<parsedate()> is called from array context, then it will return two
  elements.  On sucessful parses, it will return the seconds and what
  remains of its input string.  On unsucessful parses, it will return
  C<undef> and an error string.


pkgId: 0614575f3b10604ad2d7b48ddfda167f800d2241127e3b42b6b03f28042e0936
name: local-perl-Tree-DAG_Node
arch: noarch
version: 1.06
epoch: 0
release: 1
summary: Tree-DAG_Node - (super)class for representing nodes in a tree
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Hand, <cogent@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Tree-DAG_Node-1.06-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Tree-DAG_Node-1.06-1.noarch.rpm
checksum_type: sha256
description:
  This class encapsulates/makes/manipulates objects that represent nodes
  in a tree structure. The tree structure is not an object itself, but
  is emergent from the linkages you create between nodes.  This class
  provides the methods for making linkages that can be used to build up
  a tree, while preventing you from ever making any kinds of linkages
  which are not allowed in a tree (such as having a node be its own
  mother or ancestor, or having a node have two mothers).

  This is what I mean by a "tree structure", a bit redundantly stated:

  * A tree is a special case of an acyclic directed graph.

  * A tree is a network of nodes where there's exactly one root
  node (i.e., 'the top'), and the only primary relationship between nodes
  is the mother-daugher relationship.

  * No node can be its own mother, or its mother's mother, etc.

  * Each node in the tree has exactly one "parent" (node in the "up"
  direction) -- except the root, which is parentless.

  * Each node can have any number (0 to any finite number) of daughter
  nodes.  A given node's daughter nodes constitute an I<ordered> list.
  (However, you are free to consider this ordering irrelevant.
  Some applications do need daughters to be ordered, so I chose to
  consider this the general case.)

  * A node can appear in only one tree, and only once in that tree.
  Notably (notable because it doesn't follow from the two above points),
  a node cannot appear twice in its mother's daughter list.

  * In other words, there's an idea of up (toward the root) versus
  down (away from the root), and left (i.e., toward the start (index 0)
  of a given node's daughter list) versus right (toward the end of a
  given node's daughter list).

  Trees as described above have various applications, among them:
  representing syntactic constituency, in formal linguistics;
  representing contingencies in a game tree; representing abstract
  syntax in the parsing of any computer language -- whether in
  expression trees for programming languages, or constituency in the
  parse of a markup language document.  (Some of these might not use the
  fact that daughters are ordered.)

  (Note: B-Trees are a very special case of the above kinds of trees,
  and are best treated with their own class.  Check CPAN for modules
  encapsulating B-Trees; or if you actually want a database, and for
  some reason ended up looking here, go look at L<AnyDBM_File>.)

  Many base classes are not usable except as such -- but Tree::DAG_Node
  can be used as a normal class.  You can go ahead and say:

    use Tree::DAG_Node;
    my $root = Tree::DAG_Node->new();
    $root->name("I'm the tops");
    $new_daughter = Tree::DAG_Node->new();
    $new_daughter->name("More");
    $root->add_daughter($new_daughter);

  and so on, constructing and linking objects from Tree::DAG_Node and
  making useful tree structures out of them.


pkgId: 6654e01ae26edce94a135dcc739db1a9f190ceb429bce4586afdc5062c5385ba
name: local-perl-Tree-DAG_Node
arch: noarch
version: 1.27
epoch: 0
release: 1
summary: Tree-DAG_Node - An N-ary tree
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Sean M. Burke <sburke@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Tree-DAG_Node-1.27-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Tree-DAG_Node-1.27-1.noarch.rpm
checksum_type: sha256
description:
  This class encapsulates/makes/manipulates objects that represent nodes
  in a tree structure. The tree structure is not an object itself, but
  is emergent from the linkages you create between nodes.  This class
  provides the methods for making linkages that can be used to build up
  a tree, while preventing you from ever making any kinds of linkages
  which are not allowed in a tree (such as having a node be its own
  mother or ancestor, or having a node have two mothers).

  This is what I mean by a "tree structure", a bit redundantly stated:

  =over 4

  =item o A tree is a special case of an acyclic directed graph

  =item o A tree is a network of nodes where there's exactly one root node

  Also, the only primary relationship between nodes is the mother-daughter relationship.

  =item o No node can be its own mother, or its mother's mother, etc

  =item o Each node in the tree has exactly one parent

  Except for the root of course, which is parentless.

  =item o Each node can have any number (0 .. N) daughter nodes

  A given node's daughter nodes constitute an I<ordered> list.

  However, you are free to consider this ordering irrelevant.
  Some applications do need daughters to be ordered, so I chose to
  consider this the general case.

  =item o A node can appear in only one tree, and only once in that tree

  Notably (notable because it doesn't follow from the two above points),
  a node cannot appear twice in its mother's daughter list.

  =item o There's an idea of up versus down

  Up means towards to the root, and down means away from the root (and towards the leaves).

  =item o There's an idea of left versus right

  Left is toward the start (index 0) of a given node's daughter list, and right is toward the end of a
  given node's daughter list.

  =back

  Trees as described above have various applications, among them:
  representing syntactic constituency, in formal linguistics;
  representing contingencies in a game tree; representing abstract
  syntax in the parsing of any computer language -- whether in
  expression trees for programming languages, or constituency in the
  parse of a markup language document.  (Some of these might not use the
  fact that daughters are ordered.)

  (Note: B-Trees are a very special case of the above kinds of trees,
  and are best treated with their own class.  Check CPAN for modules
  encapsulating B-Trees; or if you actually want a database, and for
  some reason ended up looking here, go look at L<AnyDBM_File>.)

  Many base classes are not usable except as such -- but C<Tree::DAG_Node>
  can be used as a normal class.  You can go ahead and say:

  	use Tree::DAG_Node;
  	my $root = Tree::DAG_Node->new();
  	$root->name("I'm the tops");
  	$new_daughter = Tree::DAG_Node->new();
  	$new_daughter->name("More");
  	$root->add_daughter($new_daughter);

  and so on, constructing and linking objects from C<Tree::DAG_Node> and
  making useful tree structures out of them.


pkgId: b7522c96a3950ce31e12c25f8f9315bfbb992675ad28a2b1ca622f45a052c196
name: local-perl-Try-Tiny
arch: noarch
version: 0.11
epoch: 0
release: 1
summary: Try-Tiny - minimal try/catch with proper localization of $@
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Yuval Kogman <Eltnothingmuch@woobling.orgEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Try-Tiny-0.11-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Try-Tiny-0.11-1.noarch.rpm
checksum_type: sha256
description:
  This module provides bare bones C<try>/C<catch>/C<finally> statements that are designed to
  minimize common mistakes with eval blocks, and NOTHING else.

  This is unlike L<TryCatch> which provides a nice syntax and avoids adding
  another call stack layer, and supports calling C<return> from the try block to
  return from the parent subroutine. These extra features come at a cost of a few
  dependencies, namely L<Devel::Declare> and L<Scope::Upper> which are
  occasionally problematic, and the additional catch filtering uses L<Moose>
  type constraints which may not be desirable either.

  The main focus of this module is to provide simple and reliable error handling
  for those having a hard time installing L<TryCatch>, but who still want to
  write correct C<eval> blocks without 5 lines of boilerplate each time.

  It's designed to work as correctly as possible in light of the various
  pathological edge cases (see L<BACKGROUND>) and to be compatible with any style
  of error values (simple strings, references, objects, overloaded objects, etc).

  If the try block dies, it returns the value of the last statement executed in
  the catch block, if there is one. Otherwise, it returns C<undef> in scalar
  context or the empty list in list context. The following two examples both
  assign C<"bar"> to C<$x>.

  	my $x = try { die "foo" } catch { "bar" };

  	my $x = eval { die "foo" } || "bar";

  You can add finally blocks making the following true.

  	my $x;
  	try { die 'foo' } finally { $x = 'bar' };
  	try { die 'foo' } catch { warn "Got a die: $_" } finally { $x = 'bar' };

  Finally blocks are always executed making them suitable for cleanup code
  which cannot be handled using local.  You can add as many finally blocks to a
  given try block as you like.


pkgId: be3a24ad19fda0842b972e5d6f231e91eea00a6ad694470b5f76f472d4d49adb
name: local-perl-UNIVERSAL-require
arch: noarch
version: 0.13
epoch: 0
release: 1
summary: UNIVERSAL-require - require() modules from a variable
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michael G Schwern <schwern@pobox.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-UNIVERSAL-require-0.13-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-UNIVERSAL-require-0.13-1.noarch.rpm
checksum_type: sha256
description:
  If you've ever had to do this...

      eval "require $module";

  to get around the bareword caveats on require(), this module is for
  you.  It creates a universal require() class method that will work
  with every Perl module and its secure.  So instead of doing some
  arcane eval() work, you can do this:

      $module->require;

  It doesn't save you much typing, but it'll make alot more sense to
  someone who's not a ninth level Perl acolyte.


pkgId: b38f6ec43b11185113687bf2731d85362588fd34fc861fb588a207adf9a45cfd
name: local-perl-URI
arch: noarch
version: 1.58
epoch: 0
release: 1
summary: URI - Uniform Resource Identifiers (absolute and relative)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Gisle Aas <gisle@activestate.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-URI-1.58-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-URI-1.58-1.noarch.rpm
checksum_type: sha256
description:
  This module implements the C<URI> class.  Objects of this class
  represent "Uniform Resource Identifier references" as specified in RFC
  2396 (and updated by RFC 2732).

  A Uniform Resource Identifier is a compact string of characters that
  identifies an abstract or physical resource.  A Uniform Resource
  Identifier can be further classified as either a Uniform Resource Locator
  (URL) or a Uniform Resource Name (URN).  The distinction between URL
  and URN does not matter to the C<URI> class interface. A
  "URI-reference" is a URI that may have additional information attached
  in the form of a fragment identifier.

  An absolute URI reference consists of three parts:  a I<scheme>, a
  I<scheme-specific part> and a I<fragment> identifier.  A subset of URI
  references share a common syntax for hierarchical namespaces.  For
  these, the scheme-specific part is further broken down into
  I<authority>, I<path> and I<query> components.  These URIs can also
  take the form of relative URI references, where the scheme (and
  usually also the authority) component is missing, but implied by the
  context of the URI reference.  The three forms of URI reference
  syntax are summarized as follows:

    <scheme>:<scheme-specific-part>#<fragment>
    <scheme>://<authority><path>?<query>#<fragment>
    <path>?<query>#<fragment>

  The components into which a URI reference can be divided depend on the
  I<scheme>.  The C<URI> class provides methods to get and set the
  individual components.  The methods available for a specific
  C<URI> object depend on the scheme.


pkgId: ee614e0c41892a583cdb352ed05525536c1b34e29ee26176a1f39ebf8bce8db2
name: local-perl-Unicode-Map
arch: x86_64
version: 0.112
epoch: 0
release: 1
summary: Unicode-Map - maps charsets from and to utf16 unicode
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Martin Schwartz <EltFmartin@nacho.deEgt>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Unicode-Map-0.112-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Unicode-Map-0.112-1.x86_64.rpm
checksum_type: sha256
description:
  This module converts strings from and to 2-byte Unicode UCS2 format.
  All mappings happen via 2 byte UTF16 encodings, not via 1 byte UTF8
  encoding. To transform these use Unicode::String.

  For historical reasons this module coexists with Unicode::Map8.
  Please use Unicode::Map8 unless you need to care for two byte character
  sets, e.g. chinese GB2312. Anyway, if you stick to the basic
  functionality (see documentation) you can use both modules equivalently.

  Practically this module will disappear from earth sooner or later as
  Unicode mapping support needs somehow to get into perl's core. If you
  like to work on this field please don't hesitate contacting Gisle Aas!

  This module can't deal directly with utf8. Use Unicode::String to convert
  utf8 to utf16 and vice versa.

  Character mapping is according to the data of binary mapfiles in Unicode::Map
  hierarchy. Binary mapfiles can also be created with this module, enabling you
  to install own specific character sets. Refer to mkmapfile or file REGISTRY in the Unicode::Map hierarchy.


pkgId: 8630491b8ec05b4dc6bc030267e59719abbe7b0f76792187c657b8269e839d76
name: local-perl-Variable-Magic
arch: x86_64
version: 0.47
epoch: 0
release: 1
summary: Variable-Magic - Associate user-defined magic to variables from Perl.
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Vincent Pit <perl@profvince.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-Variable-Magic-0.47-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-Variable-Magic-0.47-1.x86_64.rpm
checksum_type: sha256
description:
  Magic is Perl's way of enhancing variables.
  This mechanism lets the user add extra data to any variable and hook syntactical operations (such as access, assignment or destruction) that can be applied to it.
  With this module, you can add your own magic to any variable without having to write a single line of XS.

  You'll realize that these magic variables look a lot like tied variables.
  It's not surprising, as tied variables are implemented as a special kind of magic, just like any 'irregular' Perl variable : scalars like C<$!>, C<$(> or C<$^W>, the C<%ENV> and C<%SIG> hashes, the C<@ISA> array,  C<vec()> and C<substr()> lvalues, L<threads::shared> variables...
  They all share the same underlying C API, and this module gives you direct access to it.

  Still, the magic made available by this module differs from tieing and overloading in several ways :

  =over 4

  =item *

  It isn't copied on assignment.

  You attach it to variables, not values (as for blessed references).

  =item *

  It doesn't replace the original semantics.

  Magic callbacks usually get triggered before the original action takes place, and can't prevent it from happening.
  This also makes catching individual events easier than with C<tie>, where you have to provide fallbacks methods for all actions by usually inheriting from the correct C<Tie::Std*> class and overriding individual methods in your own class.

  =item *

  It's type-agnostic.

  The same magic can be applied on scalars, arrays, hashes, subs or globs.
  But the same hook (see below for a list) may trigger differently depending on the the type of the variable.

  =item *

  It's mostly invisible at the Perl level.

  Magical and non-magical variables cannot be distinguished with C<ref>, C<tied> or another trick.

  =item *

  It's notably faster.

  Mainly because perl's way of handling magic is lighter by nature, and because there's no need for any method resolution.
  Also, since you don't have to reimplement all the variable semantics, you only pay for what you actually use.

  =back

  The operations that can be overloaded are :

  =over 4

  =item *

  C<get>

  This magic is invoked when the variable is evaluated.
  It is never called for arrays and hashes.

  =item *

  C<set>

  This one is triggered each time the value of the variable changes.
  It is called for array subscripts and slices, but never for hashes.

  =item *

  C<len>

  This magic is a little special : it is called when the 'size' or the 'length' of the variable has to be known by Perl.
  Typically, it's the magic involved when an array is evaluated in scalar context, but also on array assignment and loops (C<for>, C<map> or C<grep>).
  The callback has then to return the length as an integer.

  =item *

  C<clear>

  This magic is invoked when the variable is reset, such as when an array is emptied.
  Please note that this is different from undefining the variable, even though the magic is called when the clearing is a result of the undefine (e.g. for an array, but actually a bug prevent it to work before perl 5.9.5 - see the L<history|/PERL MAGIC HISTORY>).

  =item *

  C<free>

  This one can be considered as an object destructor.
  It happens when the variable goes out of scope, but not when it is undefined.

  =item *

  C<copy>

  This magic only applies to tied arrays and hashes.
  It fires when you try to access or change their elements.
  It is available on your perl iff C<MGf_COPY> is true.

  =item *

  C<dup>

  Invoked when the variable is cloned across threads.
  Currently not available.

  =item *

  C<local>

  When this magic is set on a variable, all subsequent localizations of the variable will trigger the callback.
  It is available on your perl iff C<MGf_LOCAL> is true.

  =back

  The following actions only apply to hashes and are available iff L</VMG_UVAR> is true.
  They are referred to as C<uvar> magics.

  =over 4

  =item *

  C<fetch>

  This magic happens each time an element is fetched from the hash.

  =item *

  C<store>

  This one is called when an element is stored into the hash.

  =item *

  C<exists>

  This magic fires when a key is tested for existence in the hash.

  =item *

  C<delete>

  This last one triggers when a key is deleted in the hash, regardless of whether the key actually exists in it.

  =back

  You can refer to the tests to have more insight of where the different magics are invoked.


pkgId: a514acaaf724e136f7427b6fa575ed6091809478ee00e96bab0d7aa4448ad084
name: local-perl-WWW-Facebook-API
arch: noarch
version: 0.4.18
epoch: 0
release: 1
summary: WWW-Facebook-API - Facebook API implementation
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: David Romano <unobe@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-WWW-Facebook-API-0.4.18-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-WWW-Facebook-API-0.4.18-1.noarch.rpm
checksum_type: sha256
description:
  A Perl implementation of the Facebook API, working off of the canonical Java
  and PHP implementations. By default it uses L<JSON::Any> to parse the response
  returned by Facebook's server. There is an option to return the raw response
  in either XML or JSON (See the C<parse> method below). As the synopsis states,
  the following environment variables are used to set the defaults for new
  instances:

      WFA_API_KEY
      WFA_SECRET
      WFA_SESSION_KEY
      WFA_DESKTOP

  Additionally, for each instance that is created, the following environment
  variables are used if no values are set:

      WFA_API_KEY_APP_PATH
      WFA_SECRET_APP_PATH
      WFA_SESSION_KEY_APP_PATH
      WFA_DESKTOP_APP_PATH

  Where C<APP_PATH> is replaced by whatever $client->app_path returns, with all
  non-alphanumeric characters replaced with an underscore and all characters
  upcased (e.g., foo-bar-baz becomes FOO_BAR_BAZ).


pkgId: 622f55be62ecb35839bccccd60f8db159acad935a628f77829c8a7e8e3ec6041
name: local-perl-WWW-Mechanize
arch: noarch
version: 1.71
epoch: 0
release: 1
summary: WWW-Mechanize - Handy web browsing in a Perl object
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Jesse Vincent <jesse@bestpractical.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-WWW-Mechanize-1.71-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-WWW-Mechanize-1.71-1.noarch.rpm
checksum_type: sha256
description:
  C<WWW::Mechanize>, or Mech for short, is a Perl module for stateful
  programmatic web browsing, used for automating interaction with
  websites.

  Features include:

  =over 4

  =item * All HTTP methods

  =item * High-level hyperlink and HTML form support, without having to parse HTML yourself

  =item * SSL support

  =item * Automatic cookies

  =item * Custom HTTP headers

  =item * Automatic handling of redirections

  =item * Proxies

  =item * HTTP authentication

  =back

  Mech supports performing a sequence of page fetches including
  following links and submitting forms. Each fetched page is parsed
  and its links and forms are extracted. A link or a form can be
  selected, form fields can be filled and the next page can be fetched.
  Mech also stores a history of the URLs you've visited, which can
  be queried and revisited.

      use WWW::Mechanize;
      my $mech = WWW::Mechanize->new();

      $mech->get( $url );

      $mech->follow_link( n => 3 );
      $mech->follow_link( text_regex => qr/download this/i );
      $mech->follow_link( url => 'http://host.com/index.html' );

      $mech->submit_form(
          form_number => 3,
          fields      => {
              username    => 'mungo',
              password    => 'lost-and-alone',
          }
      );

      $mech->submit_form(
          form_name => 'search',
          fields    => { query  => 'pot of gold', },
          button    => 'Search Now'
      );


  Mech is well suited for use in testing web applications.  If you use
  one of the Test::*, like L<Test::HTML::Lint> modules, you can check the
  fetched content and use that as input to a test call.

      use Test::More;
      like( $mech->content(), qr/$expected/, "Got expected content" );

  Each page fetch stores its URL in a history stack which you can
  traverse.

      $mech->back();

  If you want finer control over your page fetching, you can use
  these methods. C<follow_link> and C<submit_form> are just high
  level wrappers around them.

      $mech->find_link( n => $number );
      $mech->form_number( $number );
      $mech->form_name( $name );
      $mech->field( $name, $value );
      $mech->set_fields( %field_values );
      $mech->set_visible( @criteria );
      $mech->click( $button );

  L<WWW::Mechanize> is a proper subclass of L<LWP::UserAgent> and
  you can also use any of L<LWP::UserAgent>'s methods.

      $mech->add_header($name => $value);

  Please note that Mech does NOT support JavaScript, you need additional software
  for that. Please check L<WWW::Mechanize::FAQ/"JavaScript"> for more.


pkgId: c62c40df08d0d13d331f6946ba4004b4a33fc7a1296c748431eaf5f403d2ac6d
name: local-perl-WWW-RobotRules
arch: noarch
version: 6.01
epoch: 0
release: 1
summary: WWW-RobotRules - database of robots.txt-derived permissions
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Gisle Aas <gisle@activestate.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-WWW-RobotRules-6.01-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-WWW-RobotRules-6.01-1.noarch.rpm
checksum_type: sha256
description:
  This module parses F</robots.txt> files as specified in
  "A Standard for Robot Exclusion", at
  <http://www.robotstxt.org/wc/norobots.html>
  Webmasters can use the F</robots.txt> file to forbid conforming
  robots from accessing parts of their web site.

  The parsed files are kept in a WWW::RobotRules object, and this object
  provides methods to check if access to a given URL is prohibited.  The
  same WWW::RobotRules object can be used for one or more parsed
  F</robots.txt> files on any number of hosts.

  The following methods are provided:

  =over 4

  =item $rules = WWW::RobotRules->new($robot_name)

  This is the constructor for WWW::RobotRules objects.  The first
  argument given to new() is the name of the robot.

  =item $rules->parse($robot_txt_url, $content, $fresh_until)

  The parse() method takes as arguments the URL that was used to
  retrieve the F</robots.txt> file, and the contents of the file.

  =item $rules->allowed($uri)

  Returns TRUE if this robot is allowed to retrieve this URL.

  =item $rules->agent([$name])

  Get/set the agent name. NOTE: Changing the agent name will clear the robots.txt
  rules and expire times out of the cache.

  =back


pkgId: 24ff3c5518c5014551001972d496433598a9bc02f3467f6f903b22c0fddeb2a1
name: local-perl-XML-DOM
arch: noarch
version: 1.44
epoch: 0
release: 1
summary: XML-DOM - A perl module for building DOM Level 1 compliant document structures
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: patches to TJ <Mather@Ftjmather@maxmind.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-DOM-1.44-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-DOM-1.44-1.noarch.rpm
checksum_type: sha256
description:
  This module extends the XML::Parser module by Clark Cooper.
  The XML::Parser module is built on top of XML::Parser::Expat,
  which is a lower level interface to James Clark's expat library.

  XML::DOM::Parser is derived from XML::Parser. It parses XML strings or files
  and builds a data structure that conforms to the API of the Document Object
  Model as described at http://www.w3.org/TR/REC-DOM-Level-1.
  See the XML::Parser manpage for other available features of the
  XML::DOM::Parser class.
  Note that the 'Style' property should not be used (it is set internally.)

  The XML::Parser I<NoExpand> option is more or less supported, in that it will
  generate EntityReference objects whenever an entity reference is encountered
  in character data. I'm not sure how useful this is. Any comments are welcome.

  As described in the synopsis, when you create an XML::DOM::Parser object,
  the parse and parsefile methods create an I<XML::DOM::Document> object
  from the specified input. This Document object can then be examined, modified and
  written back out to a file or converted to a string.

  When using XML::DOM with XML::Parser version 2.19 and up, setting the
  XML::DOM::Parser option I<KeepCDATA> to 1 will store CDATASections in
  CDATASection nodes, instead of converting them to Text nodes.
  Subsequent CDATASection nodes will be merged into one. Let me know if this
  is a problem.

  When using XML::Parser 2.27 and above, you can suppress expansion of
  parameter entity references (e.g. %pent;) in the DTD, by setting I<ParseParamEnt>
  to 1 and I<ExpandParamEnt> to 0. See L<Hidden Nodes|/_Hidden_Nodes_> for details.

  A Document has a tree structure consisting of I<Node> objects. A Node may contain
  other nodes, depending on its type.
  A Document may have Element, Text, Comment, and CDATASection nodes.
  Element nodes may have Attr, Element, Text, Comment, and CDATASection nodes.
  The other nodes may not have any child nodes.

  This module adds several node types that are not part of the DOM spec (yet.)
  These are: ElementDecl (for <!ELEMENT ...> declarations), AttlistDecl (for
  <!ATTLIST ...> declarations), XMLDecl (for <?xml ...?> declarations) and AttDef
  (for attribute definitions in an AttlistDecl.)


pkgId: 2417fbeb268a0b416a9a40f07e5a52f3b59a787d326a4bd00bb3c8e4d9b4d9d4
name: local-perl-XML-LibXML
arch: x86_64
version: 1.88
epoch: 1
release: 1.ep
summary: Perl interface to the libxml2 library
url: http://search.cpan.org/dist/XML-LibXML/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-LibXML-1.88-1.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-XML-LibXML-1.88-1.ep.x86_64.rpm
checksum_type: sha256
description:
  This module implements a Perl interface to the GNOME libxml2 library
  which provides interfaces for parsing and manipulating XML files. This
  module allows Perl programmers to make use of the highly capable
  validating XML parser and the high performance DOM implementation.


pkgId: 820c34eacca987c6eef20d0fb4605b5c2a9a4cffd6f1d769aeb4b4099e16cddd
name: local-perl-XML-Parser
arch: x86_64
version: 2.41
epoch: 0
release: 1
summary: XML-Parser - A perl module for parsing XML documents
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Clark Cooper (coopercc@netheaven.com)
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-Parser-2.41-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-Parser-2.41-1.x86_64.rpm
checksum_type: sha256
description:
  This module provides ways to parse XML documents. It is built on top of
  L<XML::Parser::Expat>, which is a lower level interface to James Clark's
  expat library. Each call to one of the parsing methods creates a new
  instance of XML::Parser::Expat which is then used to parse the document.
  Expat options may be provided when the XML::Parser object is created.
  These options are then passed on to the Expat object on each parse call.
  They can also be given as extra arguments to the parse methods, in which
  case they override options given at XML::Parser creation time.

  The behavior of the parser is controlled either by C<L</STYLES>> and/or
  C<L</HANDLERS>> options, or by L</setHandlers> method. These all provide
  mechanisms for XML::Parser to set the handlers needed by XML::Parser::Expat.
  If neither C<Style> nor C<Handlers> are specified, then parsing just
  checks the document for being well-formed.

  When underlying handlers get called, they receive as their first parameter
  the I<Expat> object, not the Parser object.


pkgId: bb65aa697f0e4e1e18f0519410c5de923567bc445279cf3f000cdcd308ecee3b
name: local-perl-XML-Pastor
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: XML-Pastor - Generate Perl classes with XML bindings starting from a W3C XSD Schema
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ayhan Ulusoy <dev@ulusoy.name>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-Pastor-1.0.3-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-Pastor-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Java had CASTOR, and now Perl has B<XML::Pastor>!

  If you know what Castor does in the Java world, then B<XML::Pastor> should be familiar to you. If you have a B<W3C XSD schema>,
  you can generate Perl classes with roundtrip XML bindings.

  Whereas Castor is limited to offline code generation, B<XML::Pastor> is able to generate Perl classes
  either offline or at run-time starting from a W3C XSD Schema. The generated classes correspond to
  the global elements, complex and simple type declarations in the schema. The generated classes have full XML binding,
  meaning objects belonging to them can be read from and written to XML. Accessor methods for attributes and child elements will be generated automatically.
  Furthermore it is possible to validate the objects of generated classes against the original schema although the schema is typically no longer accessible.

  B<XML::Pastor> defines just one method, 'I<generate()>', but the classes it generates define many methods which may
  be found in the documentation of L<XML::Pastor::ComplexType> and L<XML::Pastor::SimpleType> from which all generated classes
  descend.

  In 'I<offline>'  mode, it is possible to generate a single module with all the generated clasess or multiple modules
  one for each class. The typical use of the offline mode is during a 'make' process, where you have a set of XSD schemas and you
  generate your modules to be later installed by the 'make install'. This is very similar to Java Castor's behaviour.
  This way your XSD schemas don't have to be accessible during run-time and you don't have a performance penalty.

  Perl philosophy dictates however, that There Is More Than One Way To Do It. In 'I<eval>' (run-time) mode, the XSD schema is processed at
  run-time giving much more flexibility to the user. This added flexibility has a price on the other hand, namely a performance penalty and
  the fact that the XSD schema needs to be accessible at run-time. Note that the performance penalty applies only to the code genereration (pastorize) phase;
  the generated classes perform the same as if they were generated offline.

  There is a command line utility called L<pastorize> that can help generating classes offline. See the documentation of L<pastorize> for more details on that.


pkgId: 91ef280f3ef393f219791e8e498eafbcc964f58a142e08db3d2b5eed951aa189
name: local-perl-XML-RegExp
arch: noarch
version: 0.04
epoch: 0
release: 1
summary: XML-RegExp - Regular expressions for XML tokens
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: tjmather@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-RegExp-0.04-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-RegExp-0.04-1.noarch.rpm
checksum_type: sha256
description:
  This package contains regular expressions for the following XML tokens:
  BaseChar, Ideographic, Letter, Digit, Extender, CombiningChar, NameChar,
  EntityRef, CharRef, Reference, Name, NmToken, and AttValue.

  The definitions of these tokens were taken from the XML spec
  (Extensible Markup Language 1.0) at L<http://www.w3.org/TR/REC-xml>.

  Also contains the regular expressions for the following tokens from the
  XML Namespaces spec at L<http://www.w3.org/TR/REC-xml-names>:
  NCNameChar, NCName, QName, Prefix and LocalPart.


pkgId: d2c53d96f3dcb07ffa1d43306feb5ea005f61cd249d8b64d05017ed5610b7ff6
name: local-perl-XML-SAX
arch: noarch
version: 0.96
epoch: 0
release: 1
summary: XML-SAX - Simple API for XML
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: maintainer Grant McLean <grantm@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-SAX-0.96-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-SAX-0.96-1.noarch.rpm
checksum_type: sha256
description:
  XML::SAX is a SAX parser access API for Perl. It includes classes
  and APIs required for implementing SAX drivers, along with a factory
  class for returning any SAX parser installed on the user's system.


pkgId: 51121716fe42b5d7bdfeb2ed590c8b4a6c4becb1fdba67d30b44da66604c3b13
name: local-perl-XML-Simple
arch: noarch
version: 2.18
epoch: 0
release: 1
summary: XML-Simple - Easy API to maintain XML (esp config files)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Grant McLean <grantm@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-Simple-2.18-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-Simple-2.18-1.noarch.rpm
checksum_type: sha256
description:
  The XML::Simple module provides a simple API layer on top of an underlying XML
  parsing module (either XML::Parser or one of the SAX2 parser modules).  Two
  functions are exported: C<XMLin()> and C<XMLout()>.  Note: you can explicity
  request the lower case versions of the function names: C<xml_in()> and
  C<xml_out()>.

  The simplest approach is to call these two functions directly, but an
  optional object oriented interface (see L<"OPTIONAL OO INTERFACE"> below)
  allows them to be called as methods of an B<XML::Simple> object.  The object
  interface can also be used at either end of a SAX pipeline.


pkgId: f6ac743a373c1c8fec6f4fe45fe423b4288c1f55403347f545706170aa32c74e
name: local-perl-XML-Twig
arch: noarch
version: 3.39
epoch: 0
release: 1
summary: XML-Twig - XML, The Perl Way
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michel Rodriguez <mirod@xmltwig.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-Twig-3.39-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-Twig-3.39-1.noarch.rpm
checksum_type: sha256
description:
  This module provides a way to process XML documents. It is build on top
  of C<XML::Parser>.

  The module offers a tree interface to the document, while allowing you
  to output the parts of it that have been completely processed.

  It allows minimal resource (CPU and memory) usage by building the tree
  only for the parts of the documents that need actual processing, through the
  use of the C<L<twig_roots> > and
  C<L<twig_print_outside_roots> > options. The
  C<L<finish> > and C<L<finish_print> > methods also help
  to increase performances.

  XML::Twig tries to make simple things easy so it tries its best to takes care
  of a lot of the (usually) annoying (but sometimes necessary) features that
  come with XML and XML::Parser.


pkgId: 40d3e29df06e0e455aa1c59272ee0159e515ef06a09a159b31060183e00c8d2b
name: local-perl-XML-XPathEngine
arch: noarch
version: 0.13
epoch: 0
release: 1
summary: XML-XPathEngine - a re-usable XPath engine for DOM-like trees
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Michel Rodriguez <mirod@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-XML-XPathEngine-0.13-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-XML-XPathEngine-0.13-1.noarch.rpm
checksum_type: sha256
description:
  This module provides an XPath engine, that can be re-used by other
  module/classes that implement trees.

  In order to use the XPath engine, nodes in the user module need to mimick
  DOM nodes. The degree of similitude between the user tree and a DOM dictates
  how much of the XPath features can be used. A module implementing all of the
  DOM should be able to use this module very easily (you might need to add
  the cmp method on nodes in order to get ordered result sets).

  This code is a more or less direct copy of the L<XML::XPath> module by
  Matt Sergeant. I only removed the XML processing part to remove the dependency
  on XML::Parser, applied a couple of patches, renamed a whole lot of methods
  to make Pod::Coverage happy, and changed the docs.

  The article eXtending XML XPath, http://www.xmltwig.com/article/extending_xml_xpath/
  should give authors who want to use this module enough background to do so.

  Otherwise, my email is below ;--)

  B<WARNING>: while the underlying code is rather solid, this module mostly lacks docs.
  As they say, "patches welcome"...


pkgId: 7000d54d3efbd03aefa4060124b00b64558c2c122a0bddea415be5a92d782d3c
name: local-perl-YAML
arch: noarch
version: 0.73
epoch: 0
release: 1
summary: YAML - YAML Ain't Markup Language (tm)
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ingy dot Net <ingy@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-YAML-0.73-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-YAML-0.73-1.noarch.rpm
checksum_type: sha256
description:
  The YAML.pm module implements a YAML Loader and Dumper based on the YAML
  1.0 specification. L<http://www.yaml.org/spec/>

  YAML is a generic data serialization language that is optimized for
  human readability. It can be used to express the data structures of most
  modern programming languages. (Including Perl!!!)

  For information on the YAML syntax, please refer to the YAML
  specification.


pkgId: 14fc5a84f4bcb99fb0c54a2e185f280dbe33f2879f901b2cfe0dc7911c51a6ad
name: local-perl-YAML-Syck
arch: x86_64
version: 1.19
epoch: 0
release: 1
summary: YAML-Syck - Fast, lightweight YAML loader and dumper
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Audrey Tang <cpan@audreyt.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-YAML-Syck-1.19-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-YAML-Syck-1.19-1.x86_64.rpm
checksum_type: sha256
description:
  This module provides a Perl interface to the B<libsyck> data serialization
  library.  It exports the C<Dump> and C<Load> functions for converting
  Perl data structures to YAML strings, and the other way around.

  B<NOTE>: If you are working with other language's YAML/Syck bindings
  (such as Ruby), please set C<$YAML::Syck::ImplicitTyping> to C<1> before
  calling the C<Load>/C<Dump> functions.  The default setting is for
  preserving backward-compatibility with C<YAML.pm>.


pkgId: 2a0a1c00f157d7dd22e485912ae3d9ea0b4bfe4df8bf319fa0ec46a3530707c2
name: local-perl-YAML-Tiny
arch: noarch
version: 1.50
epoch: 0
release: 1
summary: YAML-Tiny - Read/Write YAML files with as little code as possible
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Adam Kennedy <adamk@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-YAML-Tiny-1.50-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-YAML-Tiny-1.50-1.noarch.rpm
checksum_type: sha256
description:
  B<YAML::Tiny> is a perl class for reading and writing YAML-style files,
  written 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 B<::Tiny> family of modules is specifically
  intended to provide an ultralight and zero-dependency alternative to
  many more-thorough standard modules.

  This module is primarily for reading human-written files (like simple
  config files) and generating very simple human-readable files. Note that
  I said B<human-readable> and not B<geek-readable>. The sort of files that
  your average manager or secretary should be able to look at and make
  sense of.

  L<YAML::Tiny> does not generate comments, it won't necesarily preserve the
  order of your hashes, and it will normalise if reading in and writing out
  again.

  It only supports a very basic subset of the full YAML specification.

  Usage is targetted at files like Perl's META.yml, for which a small and
  easily-embeddable module is extremely attractive.

  Features will only be added if they are human readable, and can be written
  in a few lines of code. Please don't be offended if your request is
  refused. Someone has to draw the line, and for YAML::Tiny that someone
  is me.

  If you need something with more power move up to L<YAML> (4 megabytes of
  memory overhead) or L<YAML::Syck> (275k, but requires libsyck and a C
  compiler).

  To restate, L<YAML::Tiny> does B<not> preserve your comments, whitespace,
  or the order of your YAML data. But it should round-trip from Perl
  structure to file and back again just fine.


pkgId: c4ca228e8467f755a274cddaca63543583c44fef693fbf564989c43fc1c39fc5
name: local-perl-ack
arch: x86_64
version: 1.96
epoch: 0
release: 1
summary: ack - A grep-like program specifically for large source trees
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Lester <andy@petdance.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-ack-1.96-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-ack-1.96-1.x86_64.rpm
checksum_type: sha256
description:
  If you want to know about the F<ack> program, see the F<ack> file itself.

  No user-serviceable parts inside.  F<ack> is all that should use this.


pkgId: 823517d047ad452ba79be2f9f3f0733ae87aa8609fbb451ded603b8e58d044e1
name: local-perl-common-sense
arch: noarch
version: 3.4
epoch: 0
release: 1
summary: common-sense - save a tree AND a kitten, use common::sense!
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Marc Lehmann <schmorp@schmorp.de>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-common-sense-3.4-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-common-sense-3.4-1.noarch.rpm
checksum_type: sha256
description:
  “Nothing is more fairly distributed than common sense: no one thinks
     he needs more of it than he already has.”

     – René Descartes

  This module implements some sane defaults for Perl programs, as defined by
  two typical (or not so typical - use your common sense) specimens of Perl
  coders. In fact, after working out details on which warnings and strict
  modes to enable and make fatal, we found that we (and our code written so
  far, and others) fully agree on every option, even though we never used
  warnings before, so it seems this module indeed reflects a "common" sense
  among some long-time Perl coders.

  The basic philosophy behind the choices made in common::sense can be
  summarised as: "enforcing strict policies to catch as many bugs as
  possible, while at the same time, not limiting the expressive power
  available to the programmer".

  Two typical examples of how this philosophy is applied in practise is the
  handling of uninitialised and malloc warnings:

  =over 4

  =item I<uninitialised>

  C<undef> is a well-defined feature of perl, and enabling warnings for
  using it rarely catches any bugs, but considerably limits you in what you
  can do, so uninitialised warnings are disabled.

  =item I<malloc>

  Freeing something twice on the C level is a serious bug, usually causing
  memory corruption. It often leads to side effects much later in the
  program and there are no advantages to not reporting this, so malloc
  warnings are fatal by default.

  =back

  Unfortunately, there is no fine-grained warning control in perl, so often
  whole groups of useful warnings had to be excluded because of a single
  useless warning (for example, perl puts an arbitrary limit on the length
  of text you can match with some regexes before emitting a warning, making
  the whole C<regexp> category useless).

  What follows is a more thorough discussion of what this module does,
  and why it does it, and what the advantages (and disadvantages) of this
  approach are.


pkgId: fec8f89b9cb6da7540a37d66fa6c20d16a2e1468b57c9a1b6a13dd072cbcdbe8
name: local-perl-core
arch: x86_64
version: 5.14.1
epoch: 0
release: 162.ep
summary: Base perl metapackage
url: http://www.perl.org/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Languages
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-5.14.1-162.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-core-5.14.1-162.ep.x86_64.rpm
checksum_type: sha256
description:
  A metapackage which requires all of the perl bits and modules in the upstream
  tarball from perl.org.


pkgId: 36645bf63130a483143445680f1a4e552c153b0ce7324e4df87b33e8fc49925d
name: local-perl-devel
arch: x86_64
version: 5.14.1
epoch: 4
release: 162.ep
summary: Header #files for use in perl development
url: http://www.perl.org/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Languages
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-5.14.1-162.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-devel-5.14.1-162.ep.x86_64.rpm
checksum_type: sha256
description:
  This package contains header files and development modules.
  Most perl packages will need to install perl-devel to build.


pkgId: 8fe314b1caddba5704705c349cdfa6bd65abb1e7414488da2ba2f3a5182e61af
name: local-perl-inc
arch: noarch
version: 0.01
epoch: 0
release: 1
summary: inc - Add Named Resources to @INC
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Ingy döt Net <ingy@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-inc-0.01-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-inc-0.01-1.noarch.rpm
checksum_type: sha256
description:
  C<inc> is a module to add named Perl module install paths to @INC, in a
  concise, generic and portable way.

  It is meant for projects that take advantage of external dependency
  trees like those provided by PMIR.


pkgId: ad1bbfdda0e663e2d0beb19ca0a9f221a3824c47e408efdd507ba55128717e37
name: local-perl-libwww-perl
arch: noarch
version: 6.02
epoch: 0
release: 2
summary: libwww-perl - The World-Wide Web library for Perl
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Gisle Aas <gisle@activestate.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-libwww-perl-6.02-2.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-libwww-perl-6.02-2.noarch.rpm
checksum_type: sha256
description:
  The libwww-perl collection is a set of Perl modules which provides a
  simple and consistent application programming interface (API) to the
  World-Wide Web.  The main focus of the library is to provide classes
  and functions that allow you to write WWW clients. The library also
  contain modules that are of more general use and even classes that
  help you implement simple HTTP servers.

  Most modules in this library provide an object oriented API.  The user
  agent, requests sent and responses received from the WWW server are
  all represented by objects.  This makes a simple and powerful
  interface to these services.  The interface is easy to extend
  and customize for your own needs.

  The main features of the library are:

  =over 3

  =item *

  Contains various reusable components (modules) that can be
  used separately or together.

  =item *

  Provides an object oriented model of HTTP-style communication.  Within
  this framework we currently support access to http, https, gopher, ftp, news,
  file, and mailto resources.

  =item *

  Provides a full object oriented interface or
  a very simple procedural interface.

  =item *

  Supports the basic and digest authorization schemes.

  =item *

  Supports transparent redirect handling.

  =item *

  Supports access through proxy servers.

  =item *

  Provides parser for F<robots.txt> files and a framework for constructing robots.

  =item *

  Supports parsing of HTML forms.

  =item *

  Implements HTTP content negotiation algorithm that can
  be used both in protocol modules and in server scripts (like CGI
  scripts).

  =item *

  Supports HTTP cookies.

  =item *

  Some simple command line clients, for instance C<lwp-request> and C<lwp-download>.

  =back


pkgId: 595a259e0adef0eb04c31619905677818c7cbeaccd0dfd8a621500a28e73b6a1
name: local-perl-namespace-clean
arch: noarch
version: 0.21
epoch: 0
release: 1
summary: namespace-clean - Keep imports and functions out of your namespace
description: None.
url: http://www.cpan.org
rpm_license: Artistic
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-namespace-clean-0.21-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-namespace-clean-0.21-1.noarch.rpm
checksum_type: sha256
rpm_vendor:
  Robert 'phaylon' Sedlacek <rs@474.at>, Florian Ragwitz <rafl@debian.org>, Jesse Luehrs <doy@tozt.net>


pkgId: fc503d09b975c7349aaf8c89efefb6dc484e003a9f1541f3f3af4a8b343438b4
name: local-perl-parent
arch: noarch
version: 0.225
epoch: 1
release: 162.ep
summary: Establish an ISA relationship with base classes at compile time
url: http://www.perl.org/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-5.14.1-162.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-parent-0.225-162.ep.noarch.rpm
checksum_type: sha256
description:
  parent allows you to both load one or more modules, while setting up
  inheritance from those modules at the same time. Mostly similar in effect to:

      package Baz;

      BEGIN {
          require Foo;
          require Bar;

          push @ISA, qw(Foo Bar);
      }


pkgId: 828452d9489673925fec4a0df9d5c48f019a53f7ed6bca7e98848af7ede0b504
name: local-perl-rpm-build
arch: x86_64
version: 1.0
epoch: 0
release: 1.ep
summary: RPM helper scripts for building local-perl packages
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Tools
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-rpm-build-1.0-1.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-rpm-build-1.0-1.ep.x86_64.rpm
checksum_type: sha256
description:
  The local-perl-rpm-build package contains the scripts that are
  used to build End Point's local-perl RPM packages.  You probably
  don't really need this package.


pkgId: 95a8f60299aa4205726e94ecc6a21750afa8e0cb5452aec98605dfb6d5bae520
name: local-perl-strictures
arch: noarch
version: 1.002002
epoch: 0
release: 1
summary: strictures - turn on strict and make all warnings fatal
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: S Trout cpanMSTROUT <mst@shadowcat.co.uk>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-strictures-1.002002-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: local-perl-strictures-1.002002-1.noarch.rpm
checksum_type: sha256
description:
  I've been writing the equivalent of this module at the top of my code for
  about a year now. I figured it was time to make it shorter.

  Things like the importer in 'use Moose' don't help me because they turn
  warnings on but don't make them fatal - which from my point of view is
  useless because I want an exception to tell me my code isn't warnings clean.

  Any time I see a warning from my code, that indicates a mistake.

  Any time my code encounters a mistake, I want a crash - not spew to STDERR
  and then unknown (and probably undesired) subsequent behaviour.

  I also want to ensure that obvious coding mistakes, like indirect object
  syntax (and not so obvious mistakes that cause things to accidentally compile
  as such) get caught, but not at the cost of an XS dependency and not at the
  cost of blowing things up on another machine.

  Therefore, strictures turns on indirect checking only when it thinks it's
  running in a compilation (or pod coverage) test - though if this causes
  undesired behaviour this can be overridden by setting the
  PERL_STRICTURES_EXTRA environment variable.

  If additional useful author side checks come to mind, I'll add them to the
  _EXTRA code path only - this will result in a minor version increase (i.e.
  1.000000 to 1.001000 (1.1.0) or similar). Any fixes only to the mechanism of
  this code will result in a subversion increas (i.e. 1.000000 to 1.000001
  (1.0.1)).

  If the behaviour of 'use strictures' in normal mode changes in any way, that
  will constitute a major version increase - and the code already checks
  when its version is tested to ensure that

    use strictures 1;

  will continue to only introduce the current set of strictures even if 2.0 is
  installed.


pkgId: 9703bf51e7513e88adceab9f262a74847b7a8fdc45b41f52ca7534911654db6e
name: local-perl-tests
arch: x86_64
version: 5.14.1
epoch: 4
release: 162.ep
summary: The Perl test suite
url: http://www.perl.org/
rpm_license: GPL+ or Artistic
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Languages
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: local-perl-5.14.1-162.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: local-perl-tests-5.14.1-162.ep.x86_64.rpm
checksum_type: sha256
description:
  This package contains the test suite included with Perl 5.14.1.

  Install this if you want to test your Perl installation (binary and core
  modules).


pkgId: 0ccce06fc4ed85787c35aca24dbb8c21f865a26c0b6007b8f80f5e52d60b00be
name: lwes-devel
arch: x86_64
version: 0.23.1
epoch: 0
release: 1
summary: Header files, libraries and development documentation for lwes
url: http://lwes.sourceforge.net
rpm_license: GPL
rpm_vendor: End Point Corporation
rpm_group: Development/Libraries
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: lwes-0.23.1-1.src.rpm
rpm_packager: End Point Corporation <hosting@endpoint.com>
location_href: lwes-devel-0.23.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package contains the header files, static libraries and development
  documentation for lwes. If you like to develop programs using lwes,
  you will need to install lwes-devel.


pkgId: 074032f2e366a50c03d4837e82ef1df3da85149c9fdf479d40c93115bd6a5dbb
name: nagios
arch: x86_64
version: 3.2.3
epoch: 0
release: 11.ep
summary: Nagios monitors hosts and services and yells if somethings breaks
url: http://www.nagios.org/
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nagios-3.2.3-11.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-3.2.3-11.ep.x86_64.rpm
checksum_type: sha256
description:
  Nagios is a program that will monitor hosts and services on your
  network.  It has the ability to send email or page alerts when a
  problem arises and when a problem is resolved.  Nagios is written
  in C and is designed to run under Linux (and some other *NIX
  variants) as a background process, intermittently running checks
  on various services that you specify.

  The actual service checks are performed by separate "plugin" programs
  which return the status of the checks to Nagios. The plugins are
  available at http://sourceforge.net/projects/nagiosplug.

  This package provides the core program, web interface, and documentation
  files for Nagios. Development files are built as a separate package.


pkgId: 67801dd93101ad817ce09ea43d0b878bbd5af4cbc222313666ebf56bb4c44b52
name: nagios-devel
arch: x86_64
version: 3.2.3
epoch: 0
release: 11.ep
summary: Provides include files that Nagios-related applications may compile against
url: http://www.nagios.org/
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nagios-3.2.3-11.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-devel-3.2.3-11.ep.x86_64.rpm
checksum_type: sha256
description:
  Nagios is a program that will monitor hosts and services on your
  network. It has the ability to email or page you when a problem arises
  and when a problem is resolved. Nagios is written in C and is
  designed to run under Linux (and some other *NIX variants) as a
  background process, intermittently running checks on various services
  that you specify.

  This package provides include files that Nagios-related applications
  may compile against.


pkgId: 9b5795dd7d5f214dba8b816a656375f858405a722a3224dcfd28604aee218094
name: nagios-plugins
arch: x86_64
version: 1.4.15
epoch: 0
release: 5.ep
summary: Host/service/network monitoring program plugins for Nagios
url: http://nagiosplug.sourceforge.net/
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nagios-plugins-1.4.15-5.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-plugins-1.4.15-5.ep.x86_64.rpm
checksum_type: sha256
description:
  Nagios is a program that will monitor hosts and services on your
  network, and to email or page you when a problem arises or is
  resolved. Nagios runs on a Unix server as a background or daemon
  process, intermittently running checks on various services that you
  specify. The actual service checks are performed by separate "plugin"
  programs which return the status of the checks to Nagios. This package
  contains those plugins.


pkgId: 1ff4375c3af92a1269d4336a9c56884eee1ec4779c5d552fe5db69ef53960639
name: nagios-plugins-dummy
arch: x86_64
version: 1.4.15
epoch: 0
release: 5.ep
summary: Nagios Plugin - check_dummy
url: http://nagiosplug.sourceforge.net/
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nagios-plugins-1.4.15-5.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-plugins-dummy-1.4.15-5.ep.x86_64.rpm
checksum_type: sha256
description:
  Provides check_dummy support for Nagios.
  This plugin does not actually check anything, simply provide it with a flag
  0-4 and it will return the corresponding status code to Nagios.


pkgId: 4a83ae9c0dd5fba119bae3c8f00b935ead996eb924359ff4ac685c716fe249f3
name: nagios-plugins-endpoint
arch: src
version: 1.0
epoch: 0
release: 2.ep
summary: Host/service/network monitoring program plugins for Nagios/Icinga - End Point package
url: http://www.endpoint.com/
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-plugins-endpoint-1.0-2.ep.src.rpm
checksum_type: sha256
description:
  Nagios is a program that will monitor hosts and services on your
  network, and to email or page you when a problem arises or is
  resolved. Nagios runs on a Unix server as a background or daemon
  process, intermittently running checks on various services that you
  specify. The actual service checks are performed by separate "plugin"
  programs which return the status of the checks to Nagios. This package
  contains some custom in-house created plugins used by the End Point
  Hosting team.


pkgId: 6567dec486f6fb60e2b9df9f2f5f61a8acd19eed4c413de00b3b29f26566b2a2
name: nagios-plugins-nrpe
arch: x86_64
version: 2.12
epoch: 0
release: 19.ep
summary: Provides nrpe plugin for Nagios
url: http://www.nagios.org
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nrpe-2.12-19.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-plugins-nrpe-2.12-19.ep.x86_64.rpm
checksum_type: sha256
description:
  Nrpe is a system daemon that will execute various Nagios plugins
  locally on behalf of a remote (monitoring) host that uses the
  check_nrpe plugin.  Various plugins that can be executed by the
  daemon are available at:
  http://sourceforge.net/projects/nagiosplug

  This package provides the nrpe plugin for Nagios-related applications.


pkgId: 55c0c975ec034631e01333982c29650dccc5ee91d7f66033c36d6c6a0180d15d
name: nagios-plugins-tcp
arch: x86_64
version: 1.4.15
epoch: 0
release: 5.ep
summary: Nagios Plugin - check_tcp
url: http://nagiosplug.sourceforge.net/
rpm_license: GPLv2+
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nagios-plugins-1.4.15-5.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nagios-plugins-tcp-1.4.15-5.ep.x86_64.rpm
checksum_type: sha256
description:
  Provides check_tcp, check_ftp, check_imap, check_jabber, check_nntp,
  check_nntps, check_pop, check_simap, check_spop, check_ssmtp, check_udp
  and check_clamd support for Nagios.


pkgId: 739f0116e355025aac4f399ee5ea3ef50d18c3575db8fdce56423fb5b64a2522
name: nrpe
arch: x86_64
version: 2.12
epoch: 0
release: 19.ep
summary: Host/service/network monitoring agent for Nagios
url: http://www.nagios.org
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: nrpe-2.12-19.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: nrpe-2.12-19.ep.x86_64.rpm
checksum_type: sha256
description:
  Nrpe is a system daemon that will execute various Nagios plugins
  locally on behalf of a remote (monitoring) host that uses the
  check_nrpe plugin.  Various plugins that can be executed by the
  daemon are available at:
  http://sourceforge.net/projects/nagiosplug

  This package provides the core agent.


pkgId: b74b7eab48b28f9f4c0e5145bace45d19917834d62a5920453904f7a41695195
name: perl-Crypt-DES
arch: x86_64
version: 2.05
epoch: 0
release: 1
summary: Crypt-DES - Perl DES encryption module
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: dparis@cpan.org
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: perl-Crypt-DES-2.05-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: perl-Crypt-DES-2.05-1.x86_64.rpm
checksum_type: sha256
description:
  The module implements the Crypt::CBC interface,
  which has the following methods

  =over 4

  =item blocksize
  =item keysize
  =item encrypt
  =item decrypt

  =back


pkgId: f0f547bf7a52229172d621d26f8a9b76217b9f3b079cf51c41cdb3a0849bb187
name: perl-HTML-Lint
arch: noarch
version: 2.06
epoch: 0
release: 1
summary: HTML-Lint - check for HTML errors in a string or file
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Andy Lester <andy@petdance.com>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: perl-HTML-Lint-2.06-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: perl-HTML-Lint-2.06-1.noarch.rpm
checksum_type: sha256
description:
  my $lint = HTML::Lint->new;
      $lint->only_types( HTML::Lint::STRUCTURE );

      $lint->parse( $data );
      $lint->parse_file( $filename );

      my $error_count = $lint->errors;

      foreach my $error ( $lint->errors ) {
          print $error->as_string, "\n";
      }

  HTML::Lint also comes with a wrapper program called F<weblint> that handles
  linting from the command line:

      $ weblint http://www.cnn.com/
      http://www.cnn.com/ (395:83) <IMG SRC="spacer.gif"> tag has no HEIGHT and WIDTH attributes.
      http://www.cnn.com/ (395:83) <IMG SRC="goofus.gif"> does not have ALT text defined
      http://www.cnn.com/ (396:217) Unknown element <nobr>
      http://www.cnn.com/ (396:241) </nobr> with no opening <nobr>
      http://www.cnn.com/ (842:7) target attribute in <a> is repeated

  And finally, you can also get L<Apache::HTML::Lint> that passes any
  mod_perl-generated code through HTML::Lint and get it dumped into your
  Apache F<error_log>.

      [Mon Jun  3 14:03:31 2002] [warn] /foo.pl (1:45) </p> with no opening <p>
      [Mon Jun  3 14:03:31 2002] [warn] /foo.pl (1:49) Unknown element <gronk>
      [Mon Jun  3 14:03:31 2002] [warn] /foo.pl (1:56) Unknown attribute "x" for tag <table>


pkgId: 12a7462df85ffe7d9e4a010c1398e23f1cf8431c43364394aa37176f76fac1e4
name: perl-Math-Calc-Units
arch: noarch
version: 1.07
epoch: 0
release: 1
summary: Math-Calc-Units - Human-readable unit-aware calculator
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Steve Fink <sfink@cpan.org>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: perl-Math-Calc-Units-1.07-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: perl-Math-Calc-Units-1.07-1.noarch.rpm
checksum_type: sha256
description:
  C<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 C<ucalc> script that prints out
  all of the "readable" variants of a value. For example, C<"3 bytes">
  will only produce C<"3 byte">, but C<"3 byte / sec"> produces the
  original along with C<"180 byte / minute">, C<"10.55 kilobyte / hour">,
  etc.

  The C<Math::Calc::Units> interface only provides for string-based
  computations, which could result in a large loss of precision for some
  applications. If you need the exact result, you may pass in an extra
  parameter C<'exact'> to C<calc> or C<convert>, causing them to return a
  2-element list containing the numerical result and a string describing
  the units of that result:

      my ($value, $units) = convert("10MB/sec", "GB/day");

  (In scalar context, they just return the numeric value.)


pkgId: d71caed77fd6af105756e62ec7886270072d153b2a0e7ed2100ff9011362a521
name: perl-Nagios-Plugin
arch: noarch
version: 0.35
epoch: 0
release: 1
summary: Nagios-Plugin - A family of perl modules to streamline writing Nagios
url: http://www.cpan.org
rpm_license: Artistic
rpm_vendor: Nagios Plugin Development Team <nagiosplug-devel@lists.sourceforge.net>
rpm_group: Applications/CPAN
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: perl-Nagios-Plugin-0.35-1.src.rpm
rpm_packager: Arix International <cpan2rpm@arix.com>
location_href: perl-Nagios-Plugin-0.35-1.noarch.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: 5b0305d05dcce835c8a6edfba8dde71a95fa6082b5edd71fbd860a33ae6c8598
name: pnp4nagios
arch: x86_64
version: 0.6.16
epoch: 0
release: 1.ep
summary: Nagios performance data analysis tool
url: http://www.pnp4nagios.org/
rpm_license: GPLv2
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/System
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: pnp4nagios-0.6.16-1.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: pnp4nagios-0.6.16-1.ep.x86_64.rpm
checksum_type: sha256
description:
  PNP is an addon to nagios which analyzes performance data provided by plugins
  and stores them automatically into RRD-databases.


pkgId: 3d65ed255af803650164ee49a35df6e1b7e2daef037c006300f723a265cda1d8
name: postgresql92
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: PostgreSQL client programs and libraries
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  PostgreSQL is an advanced Object-Relational database management system
  (DBMS) that supports almost all SQL constructs (including
  transactions, subselects and user-defined types and functions). The
  postgresql package includes the client programs and libraries that
  you'll need to access a PostgreSQL DBMS server.  These PostgreSQL
  client programs are programs that directly manipulate the internal
  structure of PostgreSQL databases on a PostgreSQL server. These client
  programs can be located on the same machine with the PostgreSQL
  server, or may be on a remote machine which accesses a PostgreSQL
  server over a network connection. This package contains the command-line
  utilities for managing PostgreSQL databases on a PostgreSQL server.

  If you want to manipulate a PostgreSQL database on a local or remote PostgreSQL
  server, you need this package. You also need to install this package
  if you're installing the postgresql92-server package.


pkgId: ee270f7af5d364ca8d1c9480ba63e6ed5f41fad31fa58d58b3b0bbbcd0235a20
name: postgresql92-contrib
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: Contributed source and binaries distributed with PostgreSQL
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-contrib-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  The postgresql92-contrib package contains contributed packages that are
  included in the PostgreSQL distribution.


pkgId: ac019af708ba9c73293d19f2d2ce1fca8ac8f31c9448d67fadfe4e58b617bcff
name: postgresql92-devel
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: PostgreSQL development header files and libraries
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Development/Libraries
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-devel-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  The postgresql92-devel package contains the header files and libraries
  needed to compile C or C++ applications which will directly interact
  with a PostgreSQL database management server and the ecpg Embedded C
  Postgres preprocessor. You need to install this package if you want to
  develop applications which will interact with a PostgreSQL server.


pkgId: bc02125672b4b6e259fef496bdeff4c6f9e8bb110c6cad0c9b59ec1ab1d1e023
name: postgresql92-docs
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: Extra documentation for PostgreSQL
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-docs-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  The postgresql92-docs package includes the SGML source for the documentation
  as well as the documentation in PDF format and some extra documentation.
  Install this package if you want to help with the PostgreSQL documentation
  project, or if you want to generate printed documentation. This package also
  includes HTML version of the documentation.


pkgId: 1bea920cc24e54d5f63b26db59de92e61bafd27d1eecbb61f28ad76670c02223
name: postgresql92-libs
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: The shared libraries required for any PostgreSQL clients
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-libs-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  The postgresql92-libs package provides the essential shared libraries for any
  PostgreSQL client program or interface. You will need to install this package
  to use any other PostgreSQL package or any clients that need to connect to a
  PostgreSQL server.


pkgId: bd19f3638726a2c4812cad0b74ea98b77365d36c670865dc54fd289dafcfae43
name: postgresql92-plperl
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: The Perl procedural language for PostgreSQL
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-plperl-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  PostgreSQL is an advanced Object-Relational database management
  system. The postgresql92-plperl package contains the PL/Perl language
  for the backend.


pkgId: a54f224db52afdeec32dabada68fa33b819ea66ce75752c1e7ed6a519035b639
name: postgresql92-plpython
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: The Python procedural language for PostgreSQL
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-plpython-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  PostgreSQL is an advanced Object-Relational database management
  system. The postgresql92-plpython package contains the PL/Python language
  for the backend.


pkgId: f52d9465a7c0c7f785c3327466320e7e07dcafe00fc4c103991f79cbc863a07f
name: postgresql92-pltcl
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: The Tcl procedural language for PostgreSQL
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-pltcl-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  PostgreSQL is an advanced Object-Relational database management
  system. The postgresql92-pltcl package contains the PL/Tcl language
  for the backend.


pkgId: fb90e3b07ac1182c67976045677c6a58bdeeb1a123b07ab97c50702e4d0c03c0
name: postgresql92-server
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: The programs needed to create and run a PostgreSQL server
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-server-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  The postgresql92-server package includes the programs needed to create
  and run a PostgreSQL server, which will in turn allow you to create
  and maintain PostgreSQL databases.  PostgreSQL is an advanced
  Object-Relational database management system (DBMS) that supports
  almost all SQL constructs (including transactions, subselects and
  user-defined types and functions). You should install
  postgresql92-server if you want to create and maintain your own
  PostgreSQL databases and/or your own PostgreSQL server. You also need
  to install the postgresql package.

  This version is built with --disable-integer-datetimes to enable use of
  pg_upgrade.


pkgId: 9c6132a6b6e39f8da0773a99eed6dc61bd9a9922289d4190f34dd3e1872acd29
name: postgresql92-test
arch: x86_64
version: 9.2.1
epoch: 0
release: 1PGDG.didt.ep
summary: The test suite distributed with PostgreSQL
url: http://www.postgresql.org/
rpm_license: PostgreSQL
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Databases
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: postgresql92-9.2.1-1PGDG.didt.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: postgresql92-test-9.2.1-1PGDG.didt.ep.x86_64.rpm
checksum_type: sha256
description:
  PostgreSQL is an advanced Object-Relational database management
  system. The postgresql-test package includes the sources and pre-built
  binaries of various tests for the PostgreSQL database management
  system, including regression tests and benchmarks.


pkgId: ec2de8e18003e63ebe24912b0f2da4f3277d619755edbb10a3050b3523fbb42b
name: puppet
arch: noarch
version: 2.7.3
epoch: 0
release: 2.ep
summary: A network tool for managing many disparate systems
url: http://puppetlabs.com
rpm_license: Apache 2.0
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: puppet-2.7.3-2.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: puppet-2.7.3-2.ep.noarch.rpm
checksum_type: sha256
description:
  Puppet lets you centrally manage every important aspect of your system using a
  cross-platform specification language that manages all the separate elements
  normally aggregated in different files, like users, cron jobs, and hosts,
  along with obviously discrete elements like packages, services, and files.


pkgId: 7d53bd6216d02849428ed6527974d8ae3d6af8447ee23a3e1d7a3bb08b287c39
name: puppet-server
arch: noarch
version: 2.7.3
epoch: 0
release: 2.ep
summary: Server for the puppet system management tool
url: http://puppetlabs.com
rpm_license: Apache 2.0
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: System Environment/Base
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: puppet-2.7.3-2.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: puppet-server-2.7.3-2.ep.noarch.rpm
checksum_type: sha256
description:
  Provides the central puppet server daemon which provides manifests to clients.
  The server can also function as a certificate authority and file server.


pkgId: 2fb020021aaf3577b1dbd643e1d2517006ec6acaf8d79a19c7eb1adb76492731
name: qstat
arch: x86_64
version: 2.11
epoch: 0
release: 10.20080912svn311.ep
summary: Real-time Game Server Status for FPS game servers
url: http://sourceforge.net/projects/qstat/
rpm_license: Artistic 2.0
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Amusements/Games
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: qstat-2.11-10.20080912svn311.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: qstat-2.11-10.20080912svn311.ep.x86_64.rpm
checksum_type: sha256
description:
  QStat is a command-line program that gathers real-time statistics
  from Internet game servers. Most supported games are of the first
  person shooter variety (Quake, Half-Life, etc)


pkgId: 2c7e425b4924b3172953a834ef536beb9de3cae50db1ed07a92fb5376994e1cd
name: radiusclient-ng
arch: x86_64
version: 0.5.6
epoch: 0
release: 3.ep
summary: RADIUS protocol client library
url: http://developer.berlios.de/projects/radiusclient-ng/
rpm_license: BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Applications/Internet
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: radiusclient-ng-0.5.6-3.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: radiusclient-ng-0.5.6-3.ep.x86_64.rpm
checksum_type: sha256
description:
  Portable, easy-to-use and standard compliant library suitable for
  developing free and commercial software that need support for a RADIUS
  protocol (RFCs 2128 and 2139).


pkgId: 08f2e744bf48ee0c52b37f0743f8d3ec0d6fdf48ec87a0fd6d99d0877a4515c9
name: tmux
arch: x86_64
version: 2.9a
epoch: 0
release: 3.ep
summary: A terminal multiplexer
url: https://tmux.github.io/
rpm_license: ISC and BSD
rpm_vendor: End Point Corporation https://packages.endpoint.com/
rpm_group: Unspecified
rpm_buildhost: rhel6-build64.endpoint.com
rpm_sourcerpm: tmux-2.9a-3.ep.src.rpm
rpm_packager: End Point Hosting Team <hosting@endpoint.com>
location_href: tmux-2.9a-3.ep.x86_64.rpm
checksum_type: sha256
description:
  tmux is a "terminal multiplexer."  It enables a number of terminals (or
  windows) to be accessed and controlled from a single terminal.  tmux is
  intended to be a simple, modern, BSD-licensed alternative to programs such
  as GNU Screen.


# files

type: file
name:
  /usr/local/share/doc/local-perl-mod_perl-2.0.5/ModPerl-Registry/t/cgi-bin/runtime_error_plus_body.pl


type: file
name:
  /usr/local/share/doc/local-perl-mod_perl-2.0.5/ModPerl-Registry/t/cgi-bin/runtime_error_n_status_change.pl


