Ports Search

The Inline::Java module allows you to put Java source code directly "inline" in a Perl script or module. A Java compiler is launched and the Java code is compiled. Then Perl asks the Java classes what public methods have been defined. These classes and methods are available to the Perl program as if they had been written in Perl. The process of interrogating the Java classes for public methods occurs the first time you run your Java code. The namespace is cached, and subsequent calls use the cached version.

This module provides a number of list utility functions, all of which take an initial code block to control their behaviour. They are variations on similar core perl or List::Util functions of similar names, but which use the block to control their behaviour. For example, the core Perl function sort takes a list of values and returns them, sorted into order by their string value. The sort_by function sorts them according to the string value returned by the extra function, when given each value.

The Inline::Tcl module allows you to put Tcl source code directly "inline" in a Perl script or module. A Tcl interpreter is loaded and the Tcl code is interpreted, then Perl asks the Tcl interpreter which global procedures have been defined. Those functions are made available to your Perl program as if they had been written in Perl. The process of interrogating the Tcl interpreter for globals only occurs the first time you run your Tcl code. The namespace is cached, and subsequent calls use the cached version.

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.

Mac::FileSpec::Unixish provides two functions, `nativize' and `unixify' (both of which are exported by default), that will allow you to denote and manipulate pathspecs in Unixish style, and let you convert these pathspecs to and from the native OS's format for conveying such things. It currently assumes that if you are not running under MacOS (as reported in `$^O'), you must be on a Unix box. If you want better, use File::Spec -- in essence, Mac::FileSpec::Unixish is a cheap hack to get around using File::Spec.

fb-adb is a tool for interacting with Android systems. It does much of what adb does, but with better remote shell support and, hopefully, fewer bugs. Differences between adb and fb-adb are that fb-adb: * is binary clean (no LF -> CRLF mangling) * transmits and updates window size * distinguishes standard output and standard error * properly muxes streams with independent flow control * allows for ssh-like pty allocation control * propagates program exit status instead of always exiting with status 0 * properly escapes program arguments * kills remote program * provides a generic facility to elevate to root without re-escaping

Moo is an extremely light-weight Object Orientation system. It allows one to concisely define objects and roles with a convenient syntax that avoids the details of Perl's object system. Moo contains a subset of Moose and is optimised for rapid startup. The name Moo is based on the idea that it provides almost -- but not quite -- two thirds of Moose. Unlike Mouse this module does not aim at full compatibility with Moose's surface syntax, preferring instead to provide full interoperability via metaclass inflation capabilities.

This is a utility that creates common Moose subtypes, coercions and option specifications useful for dealing with Path::Class objects as Moose attributes. This module constructs coercions (see Moose::Util::TypeConstraints) from both 'Str' and 'ArrayRef' to both Path::Class::Dir and Path::Class::File objects. It also adds the Getopt option type ("=s") for both Path::Class::Dir and Path::Class::File (see MooseX::Getopt). This is just meant to be a central place for these constructs, so you don't have to worry about whether they've been created or not, and you're not tempted to copy them into yet another class (like I was).

A structured type constraint is a standard container Moose type constraint, such as an ArrayRef or HashRef, which has been enhanced to allow you to explicitly name all the allowed type constraints inside the structure. The generalized form is: TypeConstraint[@TypeParameters or %TypeParameters] Where 'TypeParameters' is an array reference or hash references of Moose::Meta::TypeConstraint objects. This type library enables structured type constraints. It is built on top of the MooseX::Types library system, so you should review the documentation for that if you are not familiar with it.

RecDescent incrementally generates top-down recursive-descent text parsers from simple yacc-like grammar specifications. It provides: * Regular expressions or literal strings as terminals (tokens) * Multiple (non-contiguous) productions for any rule * Repeated, optional and alternate subrules within productions * Late-bound (run-time dispatched) subrules * Full access to Perl within actions specified as part of the grammar * Simple automated error reporting during generation and parsing * The ability to commit to, uncommit to, or reject particular productions during a parse * Incremental extension of the parsing grammar (even during a parse) * The ability to retrieve the generated parsing code.