Zen

Translation

English tumbleweed/perl-IO-Pipely/summary
Portably create pipe() or pipe-like handles, one way or another
66/630 · 63

Sign in to save the translation.

English Indonesian Actions
This is an HTTP request parser. It takes chunks of text as received and returns a 'hint' as to what is required, or returns the HTTP::Request when a complete request has been read. HTTP/1.1 chunking is supported. It dies if it finds an error.
 
PSGI handler for HTTP::Server::Simple
 
HTTP::Server::Simple::PSGI is a HTTP::Server::Simple based HTTP server that can run PSGI applications. This module only depends on HTTP::Server::Simple, which itself doesn't depend on any non-core modules so it's best to be used as an embedded web server.
 
Small, simple, correct HTTP/1.1 client
Klien http/1.1 kecil, sederhana, benar
HTTP::Tiny compatible HTTP client wrappers
 
HTTP::Tinyish is a wrapper module for HTTP client modules LWP, HTTP::Tiny and HTTP client software 'curl' and 'wget'.

It provides an API compatible to HTTP::Tiny, and the implementation has been extracted out of App::cpanminus. This module can be useful in a restrictive environment where you need to be able to download CPAN modules without an HTTPS support in built-in HTTP library.
 
Perl extensions for keeping data partially sorted
Ekstensi perl untuk data sewenang-wenang hexdumping
The Heap collection of modules provide routines that manage a heap of elements. A heap is a partially sorted structure that is always able to easily extract the smallest of the elements in the structure (or the largest if a reversed compare routine is provided).

If the collection of elements is changing dynamically, the heap has less overhead than keeping the collection fully sorted.

The elements must be objects as described in "Heap::Elem" and all elements inserted into one heap must be mutually compatible - either the same class exactly or else classes that differ only in ways unrelated to the
*Heap::Elem* interface.
 
This collection of modules allows programs to be written that perform asynchronous filehandle IO operations. A typical program using them would consist of a single subclass of IO::Async::Loop to act as a container of other objects, which perform the actual IO work required by the program. As well as IO handles, the loop also supports timers and signal handlers, and includes more higher-level functionality built on top of these basic parts.
 
(DEPRECATED) capture STDOUT and STDERR from Perl code, subprocesses or XS
(TIDAK DIGUNAKAN LAGI) menangkap STDOUT dan STDERR dari kode Perl, subproses atau XS
*This module is no longer recommended by the maintainer* - see Capture::Tiny instead.

This module provides routines for capturing STDOUT and STDERR from perl subroutines, forked system calls (e.g. 'system()', 'fork()') and from XS or C modules.
* Modul ini tidak lagi direkomendasikan oleh maintainer * - lihat Capture::Tiny sebagai gantinya.

Modul ini menyediakan rutinitas untuk menangkap STDOUT dan STDERR dari subroutines perl, panggilan sistem beralut (misalnya 'system()', 'fork()') dan dari modul XS atau C.
Write lzma files/buffers
 
This module provides a Perl interface that allows writing lzma compressed data to files or buffer.

For reading lzma files/buffers, see the companion module IO::Uncompress::UnLzma.
 
IO::HTML provides an easy way to open a file containing HTML while automatically determining its encoding. It uses the HTML5 encoding sniffing algorithm specified in section 8.2.2.2 of the draft standard.

The algorithm as implemented here is:
* 1.

If the file begins with a byte order mark indicating UTF-16LE, UTF-16BE, or UTF-8, then that is the encoding.
* 2.

If the first '$bytes_to_check' bytes of the file contain a '<meta>' tag that indicates the charset, and Encode recognizes the specified charset name, then that is the encoding. (This portion of the algorithm is implemented by 'find_charset_in'.)

The '<meta>' tag can be in one of two formats:

<meta charset="..."> <meta http-equiv="Content-Type" content="...charset=...">

The search is case-insensitive, and the order of attributes within the tag is irrelevant. Any additional attributes of the tag are ignored. The first matching tag with a recognized encoding ends the search.
* 3.

If the first '$bytes_to_check' bytes of the file are valid UTF-8 (with at least 1 non-ASCII character), then the encoding is UTF-8.
* 4.

If all else fails, use the default character encoding. The HTML5 standard suggests the default encoding should be locale dependent, but currently it is always 'cp1252' unless you set '$IO::HTML::default_encoding' to a different value. Note: 'sniff_encoding' does not apply this step; only 'html_file' does that.
 
This module provides a number of helpful routines to manipulate or create IO::Handle like objects.
Modul ini menyediakan sejumlah rutinitas bermanfaat untuk memanipulasi atau membuat IO::Handle seperti objek.
Portably create pipe() or pipe-like handles, one way or another
Buat pipa () atau gagang seperti pipa, dengan satu atau lain cara.
Low-level allocate a pseudo-Tty, import constants
Tingkat rendah mengalokasikan pseudo-Tty, mengimpor konstanta
'IO::Tty' is used internally by 'IO::Pty' to create a pseudo-tty. You wouldn't want to use it directly except to import constants, use 'IO::Pty'. For a list of importable constants, see IO::Tty::Constant.

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

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

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

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

If it's working on your system, please send me a short note with details (version number, distribution, etc. 'uname -a' and 'perl -V' is a good start; also, the output from "perl Makefile.PL" contains a lot of interesting info, so please include that as well) so I can get an overview. Thanks!
 
I/O on in-core objects like strings and arrays
 
This toolkit primarily provides modules for performing both traditional and object-oriented i/o) on things _other_ than normal filehandles; in particular, IO::Scalar, IO::ScalarArray, and IO::Lines.

In the more-traditional IO::Handle front, we have IO::AtomicFile which may be used to painlessly create files which are updated atomically.

And in the "this-may-prove-useful" corner, we have IO::Wrap, whose exported wraphandle() function will clothe anything that's not a blessed object in an IO::Handle-like wrapper... so you can just use OO syntax and stop worrying about whether your function's caller handed you a string, a globref, or a FileHandle.
 
Calling Perl's in-built 'system()' function is easy, determining if it was successful is _hard_. Let's face it, '$?' isn't the nicest variable in the world to play with, and even if you _do_ check it, producing a well-formatted error string takes a lot of work.

'IPC::System::Simple' takes the hard work out of calling external commands. In fact, if you want to be really lazy, you can just write:

use IPC::System::Simple qw(system);

and all of your 'system' commands will either succeed (run to completion and return a zero exit value), or die with rich diagnostic messages.

The 'IPC::System::Simple' module also provides a simple replacement to Perl's backticks operator. Simply write:

use IPC::System::Simple qw(capture);

and then use the capture() command just like you'd use backticks. If there's an error, it will die with a detailed description of what went wrong. Better still, you can even use 'capturex()' to run the equivalent of backticks, but without the shell:

use IPC::System::Simple qw(capturex);

my $result = capturex($command, @args);

If you want more power than the basic interface, including the ability to specify which exit values are acceptable, trap errors, or process diagnostics, then read on!
 
This module is a thin wrapper for JSON::XS-compatible modules with a few additional features. All the backend modules convert a Perl data structure to a JSON text and vice versa. This module uses JSON::XS by default, and when JSON::XS is not available, falls back on JSON::PP, which is in the Perl core since 5.14. If JSON::PP is not available either, this module then falls back on JSON::backportPP (which is actually JSON::PP in a different .pm file) bundled in the same distribution as this module. You can also explicitly specify to use Cpanel::JSON::XS, a fork of JSON::XS by Reini Urban.

All these backend modules have slight incompatibilities between them, including extra features that other modules don't support, but as long as you use only common features (most important ones are described below), migration from backend to backend should be reasonably easy. For details, see each backend module you use.
 
This module first checks to see if either Cpanel::JSON::XS or JSON::XS (at at least version 3.0) is already loaded, in which case it uses that module. Otherwise it tries to load Cpanel::JSON::XS, then JSON::XS, then JSON::PP in order, and either uses the first module it finds or throws an error.

It then exports the 'encode_json' and 'decode_json' functions from the loaded module, along with a 'JSON' constant that returns the class name for calling 'new' on.

If you're writing fresh code rather than replacing JSON.pm usage, you might want to pass options as constructor args rather than calling mutators, so we provide our own 'new' method that supports that.
 
Parse JSON
 
A module for parsing JSON. (JSON means "JavaScript Object Notation" and it is specified in RFC 8259.)

JSON::Parse offers the function parse_json, which takes a string containing JSON, and returns an equivalent Perl structure. It also offers validation of JSON via valid_json, which returns true or false depending on whether the JSON is correct or not, and assert_valid_json, which produces a descriptive fatal error if the JSON is invalid. A function read_json reads JSON from a file, and there is a safer version of parse_json called parse_json_safe which doesn't throw exceptions.

For special cases of parsing, there are also methods new and parse, which create a JSON parsing object and run it on text. See METHODS.

JSON::Parse accepts only UTF-8 as input. See UTF-8 only and Handling of Unicode.
 
This module converts Perl data structures to JSON and vice versa. Its primary goal is to be _correct_ and its secondary goal is to be _fast_. To reach the latter goal it was written in C.

See MAPPING, below, on how JSON::XS maps perl values to JSON values and vice versa.
Modul ini mengonversi struktur data Perl ke JSON dan sebaliknya. Tujuan utamanya adalah untuk menjadi _benar_ dan tujuan sekundernya adalah menjadi _fast_. Untuk mencapai tujuan terakhir itu ditulis di C.

Lihat PEMETAAN, di bawah ini, tentang bagaimana JSON::XS memetakan nilai perl ke nilai JSON dan sebaliknya.
'JavaScript::Minifier::XS' is a JavaScript "minifier"; its designed to remove unnecessary whitespace and comments from JavaScript files, which also *not* breaking the JavaScript.

'JavaScript::Minifier::XS' is similar in function to 'JavaScript::Minifier', but is substantially faster as its written in XS and not just pure Perl.
'JavaScript::Minifier::XS' adalah "minifier" JavaScript; dirancang untuk menghapus spasi dan komentar yang tidak diperlukan dari file JavaScript, yang juga *tidak* melanggar JavaScript.

'JavaScript::Minifier::XS' mirip dengan fungsi 'JavaScript::Minifier', tetapi secara substansial lebih cepat seperti yang ditulis dalam XS dan bukan hanya Perl murni.
LWP tracing and debugging
 
BETA BETA BETA. This is currently an experiment. Things could change. Please adjust accordingly.

It can be hard (or at least tedious) to debug mechanize scripts. LWP::Debug is deprecated. It suggests you write your own debugging handlers, set up a proxy or install Wireshark. Those are all workable solutions, but this module exists to save you some of that work. The guts of this module are stolen from Plack::Middleware::DebugLogging, which in turn stole most of its internals from Catalyst. If you're new to LWP::ConsoleLogger, I suggest getting started with the LWP::ConsoleLogger::Easy wrapper. This will get you up and running in minutes. If you need to tweak the settings that LWP::ConsoleLogger::Easy chooses for you (or if you just want to be fancy), please read on.

Since this is a debugging library, I've left as much mutable state as possible, so that you can easily toggle output on and off and otherwise adjust how you deal with the output.
 
Guess media type for a file or a URL
Tebak tipe media untuk file atau URL
This module provides functions for handling media (also known as MIME) types and encodings. The mapping from file extensions to media types is defined by the _media.types_ file. If the _~/.media.types_ file exists it is used instead. For backwards compatibility we will also look for _~/.mime.types_.

The following functions are exported by default:
* guess_media_type( $filename )
* guess_media_type( $uri )
* guess_media_type( $filename_or_object, $header_to_modify )

This function tries to guess media type and encoding for a file or objects that support the a 'path' or 'filename' method, eg, URI or File::Temp objects. When an object does not support either method, it will be stringified to determine the filename. It returns the content type, which is a string like '"text/html"'. In array context it also returns any content encodings applied (in the order used to encode the file). You can pass a URI object reference, instead of the file name.

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

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

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

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

The following functions are only exported by explicit request:
* add_type( $type, @exts )

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

add_type("x-world/x-vrml" => qw(wrl vrml));
* add_encoding( $type, @ext )

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

add_encoding("x-gzip" => "gz");
* read_media_types( @files )

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

read_media_types("conf/mime.types");
 

Loading…

No matching activity found.
Browse all string changes

Things to check

Mismatched full stop

Source and translation do not both end with a full stop

Reset

Glossary

English Indonesian
No related strings found in the glossary.

String information

Source string description
tumbleweed/perl-IO-Pipely/summary
String age
2 years ago
Last updated
2 weeks ago
Source string age
2 years ago
Translation file
id/po/perl.id.po, string 2582