Data::IEEE754 provides some simple convenience functions for packing and
unpacking IEEE 754 floats and doubles.
Currently this module only implements big-endian order.
WWW: http://search.cpan.org/dist/Data-IEEE754/
The existing devel/kyua package should have been named devel/kyua-cli to
match the upstream structure. Do the rename now and make devel/kyua be
a meta-port that depends on all kyua packages.
Because there is no version number to represent Kyua as a whole (that's
a problem I have to resolve upstream somehow), bump the epoch of
devel/kyua and use today's date as the version.
No entry should be necessary in MOVED because upgrading to the new
meta-port should do the right thing.
Approved by: bdrewery
Simply loading this module makes your constructors "strict". If your constructor
is called with an attribute init argument that your class does not declare, then
it dies. This is a great way to catch small typos.
WWW: http://search.cpan.org/dist/MooX-StrictConstructor/
Test::Bits provides a single subroutine, bits_is(), for testing binary data.
This module is quite similar to Test::BinaryData and Test::HexString in concept.
The difference is that this module shows failure diagnostics in a different way,
and has a slightly different calling style. Depending on the nature of the data
you're working with, this module may be easier to work with.
WWW: http://search.cpan.org/dist/Test-Bits/
Documentation was integrated into the recent updated of devel/adabooch.
This port is obsolete and can be removed immediately (and I highly doubt
a single user had it installed based on state of adabooch).
performance and highly flexible algorithms. It can be used as a supplement
to GLib (to add additional functions (dictionaries, hashes), or replace
some of the slow GLib list manipulation functions), or stand alone. It
also provides a powerful hook system and convenient logging for your code,
as well as a high performance block allocator.
WWW: http://www.atheme.org/project/mowgli
some Linux applications such as Matlab, which allows the user to integrate
custom C, C++, and Fortran code via the MEX compiler.
PR: ports/184549
Submitted by: Jason Bacon <jwbacon (at) tds.net>
Celluloid::IO provides an event-driven IO system for building fast, scalable
network applications that integrates directly with the Celluloid actor library,
making it easy to combine both threaded and evented concepts. Celluloid::IO is
ideal for servers which handle large numbers of mostly-idle connections, such as
Websocket servers or chat/messaging systems.
Celluloid::IO provides a different class of actor: one that's slightly slower
and heavier than standard Celluloid actors, but one which contains a
high-performance reactor just like EventMachine or Cool.io. This means
Celluloid::IO actors have the power of both Celluloid actors and evented I/O
loops. Unlike certain other evented I/O systems which limit you to a single
event loop per process, Celluloid::IO lets you make as many actors as you want,
system resources permitting.
Rather than callbacks, Celluloid::IO exposes a synchronous API built on duck
types of Ruby's own IO classes, such as TCPServer and TCPSocket. These classes
work identically to their core Ruby counterparts, but in the scope of
Celluloid::IO actors provide "evented" performance. Since they're drop-in
replacements for the standard classes, there's no need to rewrite every library
just to take advantage of Celluloid::IO's event loop and you can freely switch
between evented and blocking IO even over the lifetime of a single connection.
WWW: https://github.com/celluloid/celluloid-io
RG: https://rubygems.org/gems/celluloid-io
nio4r provides an abstract, cross-platform stateful I/O selector API for Ruby.
I/O selectors are the heart of "reactor"-based event loops, and monitor multiple
I/O objects for various types of readiness, e.g. ready for reading or writing.
The most similar API provided by Ruby today is Kernel.select, however the select
API requires you to pass in arrays of all of the I/O objects you're interested
in every time. nio4r provides a more object-oriented API that lets you register
I/O objects with a selector then handle them when they're selected for various
types of events.
nio4r is modeled after the Java NIO API, but simplified for ease-of-use.
Its goals are:
- Expose high-level interfaces for stateful IO selectors
- Keep the API small to maximize both portability and performance across many
different OSes and Ruby VMs
- Provide inherently thread-safe facilities for working with IO objects
WWW: https://github.com/celluloid/nio4r
RG: https://rubygems.org/gems/nio4r
Yappi is designed to work on long-running multi-threaded applications.
It is possible to profile an application, retrieve statistics, then stop and
start later on the fly without affecting the profiled application.
WWW: https://pypi.python.org/pypi/yappi/
PR: ports/186157
Submitted by: Johannes Jost Meixner <xmj@chaot.net>
This repository holds all interfaces/classes/traits related to PSR-3.
WWW: https://github.com/php-fig/log
PR: ports/186222
Submitted by: Gasol Wu <gasol.wu@gmail.com>
Add support for method calls on primitive types in PHP
This extension implements the ability to register a class that handles the
method calls to a certain primitive type (string, array, ...). As such it
allows implementing APIs like $str->length().
The main purpose of this repo is to provide a proof of concept implementation
that can be used to design the new APIs. The switch to object syntax for
operations on primitive types is a unique opportunity for PHP to redesign many
of its inconsistent core APIs. This repo provides the means to quickly
prototype and test new APIs as userland code. Once the APIs are figured out it
will be proposed for inclusion into PHP.
Note: The ability to register type handlers from userland is just for
prototyping.
WWW: https://github.com/nikic/scalar_objects
PR: ports/186221
Submitted by: Gasol Wu <gasol.wu@gmail.com>
Python bindinds for Apache Qpid, which speak AMQP and support many languages
and platforms.
AMQP is an open internet protocol for reliably sending and receiving messages.
It makes it possible for everyone to build a diverse, coherent messaging
ecosystem.
WWW: https://qpid.apache.org/
Tapi is a tool to automate the testing of your Application Programmer Interfaces
(APIs). Features:
* Test you API without writing any code (only edit a json file)
* Test you APIs in a much more 'natural' way by specifying urls/verbs and what
the output should be
* Verify anything from response status codes, headers, body content etc
* Also allows verification by issuing another API call to a different endpoint
to ensure a prior API call worked
* Execute arbitrary python scripts to populate request paramaters e.g. custom
headers
* Execute arbitrary python scripts to verify response from endpoint is valid
* Tests your APIs using your own APIs
WWW: https://github.com/jimmyislive/tapi/
PR: ports/186342
Submitted by: Johannes Jost Meixner <xmj@chaot.net>
your code pretty
Use styles, color, and maybe a little positioning without necessarily
clearing the whole screen first. Leave more than one screenful of
scrollback in the buffer after your program exits, like a well-behaved
command-line app should. Get rid of all those noisy, C-like calls to
tigetstr and tparm, so your code doesn't get crowded out by terminal
bookkeeping. Act intelligently when somebody redirects your output to a
file, omitting the terminal control codes the user doesn't want to see.
WWW: https://github.com/erikrose/blessings
user_agents is a Python library that provides an easy way to identify/detect
devices like mobile phones, tablets and their capabilities by parsing (browser) user agent strings. The goal is to reliably detect whether:
-- User agent is a mobile, tablet or PC based device
-- User agent has touch capabilities (has touch screen)
user_agents relies on the excellent ua-parser to do the actual parsing of the
raw user agent string.
Python bindings for the Capstone Disassembly Engine
Capstone is a disassembly framework with the target of becoming the ultimate
disasm engine for binary analysis and reversing in the security community.
WWW: http://www.capstone-engine.org
Capstone is a lightweight multi-platform, multi-architecture disassembly
framework.
Features:
* Supported architectures: ARM, ARM64 (aka ARMv8), Mips, PowerPC & X86
* Clean/simple/lightweight/intuitive architecture-neutral API
* Provide details on disassembled instruction (called "decomposer")
* Provide some semantics of the disassembled instruction, such as list of
implicit registers read & written.
* Implemented in pure C language, with bindings for Python, Ruby, C#, Java,
GO, OCaml & Vala available.
* Native support for Windows & *nix (including MacOSX, Linux, *BSD & Solaris)
* Thread-safe by design
* Distributed under the open source BSD license
WWW: http://capstone-engine.org/
PR: ports/186102
Submitted by: Oliver Pinter <oliver.pntr@gmail.com>
LLnextgen is an Extended-LL(1) parser generator. It is a rewrite of the LLgen
parser generator by D. Grune and C.J.H. Jacobs which is part of the Amsterdam
Compiler Kit (ACK). Like all parser generators, LLnextgen takes the description
of the grammar with associated actions as input, and generates a parser routine
for use in compilers and other text processing programs.
PR: ports/185458
Submitted by: Oleksii Tsai <oleksii.tsai@googlemail.com>
use this module, all references to time and sleep will be
internalized. You can set custom time by passing time => number after
the use statement.
WWW: http://search.cpan.org/dist/Test-Time/
