Results 2,571–2,580 of 5,623 for /devel/.(0.005 seconds)
Transport agnostic JSON RPC helper objects
p5::JSON::RPC-Common is a perl module provides abstractions for
JSON-RPC 1.0, 1.1 (both variations) and 2.0 (formerly 1.2)
Procedure Call and Procedure Return objects (formerly known as
request and result), along with error objects. It also provides
marshalling objects to convert the model objects into JSON text
and HTTP requests/responses.
JSON-RPC 2.0 server
JSON::RPC::Dispatcher can make any PSGI/Plack aware server a
JSON-RPC 2.0 server. This will allow you to expose your custom
functionality as a web service in a relatiely tiny amount of
code, as you can see above.
This module follows the draft specficiation for JSON-RPC 2.0.
More information can be found at:
http://groups.google.com/group/json-rpc/web/json-rpc-2-0.
Perl extension to bring loggers and listeners together
Log::Any allows CPAN modules to safely and efficiently log messages,
while letting the application choose (or decline to choose) a logging
mechanism such as Log::Dispatch or Log::Log4perl.
Perl implementation of JSON-RPC 1.1 protocol
JSON::RPC - Perl implementation of JSON-RPC 1.1 protocol.
Validate JSON against a schema
Validate JSON against a schema.
Clean imports from package-exporting modules
Lexical::Import allows functions and other items, from a separate module, to be
imported into the lexical namespace (as implemented by Lexical::Var), when the
exporting module exports non-lexically to a package in the traditional manner.
This is a translation layer, to help code written in the new way to use modules
written in the old way.
A lexically-imported item takes effect from the end of the definition statement
up to the end of the immediately enclosing block, except where it is shadowed
within a nested block. This is the same lexical scoping that the my, our, and
state keywords supply. Within its scope, any use of the single-part name of the
item (e.g., "$foo") refers directly to that item, regardless of what is in any
package. Explicitly package-qualified names (e.g., "$main::foo") still refer to
the package. There is no conflict between a lexical name definition and the same
name in any package.
This mechanism only works on Perl 5.11.2 and later. Prior to that, it is
impossible for lexical subroutine imports to work for bareword subroutine calls.
(See "BUGS" in Lexical::Var for details.) Other kinds of lexical importing are
possible on earlier Perls, but because this is such a critical kind of usage in
most code, this module will ensure that it works, for convenience. If the
limited lexical importing is desired on earlier Perls, use Lexical::Var
directly.
Persistent lexical variable values for arbitrary calls
Lexical::Persistence does a few things, all related. Note that all the
behaviors listed here are the defaults. Subclasses can override nearly
every aspect of Lexical::Persistence's behavior.
Lexical::Persistence lets your code access persistent data through lexical
variables. This example prints "some value" because the value of $x
persists in the $lp object between setter() and getter().
use Lexical::Persistence;
my $lp = Lexical::Persistence->new();
$lp->call(\&setter);
$lp->call(\&getter);
sub setter { my $x = "some value" }
sub getter { print my $x, "\n" }
Perl module to prevent leakage of lexical hints
Perl module to prevent leakage of lexical hints
Lexical::SealRequireHints works around two historical bugs in Perl's handling of
the %^H (lexical hints) variable. One bug causes lexical state in one file to
leak into another that is required/used from it. This bug, [perl #68590], was
present from Perl 5.6 up to Perl 5.10, fixed in Perl 5.11.0. The second bug
causes lexical state (normally a blank %^H once the first bug is fixed) to leak
outwards from utf8.pm, if it is automatically loaded during Unicode regular
expression matching, into whatever source is compiling at the time of the regexp
match. This bug, [perl #73174], was present from Perl 5.8.7 up to Perl 5.11.5,
fixed in Perl 5.12.0.
Both of these bugs seriously damage the usability of any module relying on %^H
for lexical scoping, on the affected Perl versions. It is in practice essential
to work around these bugs when using such modules. On versions of Perl that
require such a workaround, this module globally changes the behaviour of
require, including use and the implicit require performed in Unicode regular
expression matching, so that it no longer exhibits these bugs.
Perl module for static variables without namespace pollution
Perl module for static variables without namespace pollution
Lexical::Var and Lexical::Sub implement lexical scoping of static variables and
subroutines. Although it can be used directly, it is mainly intended to be
infrastructure for modules that export particular objects.
Lexical::Var only manages variables of static duration (the kind of duration
that our and state variables have). To get a fresh variable for each invocation
of a function, use my.
Lexical::Sub is implemented through the mechanism of Lexical::Var. Its distinct
name and declaration syntax exist to make lexical subroutine declarations
clearer.
Transliterates text between writing systems
Lingua::Translit can be used to convert text from one writing system to
another, based on national or international transliteration tables. Where
possible a reverse transliteration is supported.