API v0.6

• assert

  Assertion library covering the CommonJS Unit Testing specification and a few additional convenience methods.

• binary

  This module provides implementations of the Binary, ByteArray, and ByteString classes as defined in the CommonJS Binary/B proposal.

  The JavaScript Binary class serves as common base class for ByteArray and ByteString and can't be instantiated. ByteArray implements a modifiable and resizable byte buffer, while ByteString implements an immutable byte sequence. The ByteArray and ByteString constructors can take several arguments. Have a look at the proposal for details.

  When passed to a Java method that expects a byte array, instances of these class are automatically unwrapped. Use the {@link #unwrap()} method to explicitly get the wrapped Java byte array.

• fs

  This module provides an implementation of "fs" as defined by the CommonJS Filesystem/A proposal.

  The "fs" module provides a file system API for the manipulation of paths, directories, files, links, and the construction of file streams in addition to the functions exported by fs-base.

• fs-base

  This module provides an implementation of "fs-base" as defined by the CommonJS Filesystem/A/0 proposal.

• io

  This module implements the Stream/TextStream classes as per the CommonJS IO/A proposal.

• packages

  This module provides support for loading CommonJS and Narwhal packages.

• sandbox

  A compatibility module for Narwhal's sandbox. RingoJS is auto-reloading by default, so this is just a proxy to require().

• system

  This module provides an implementation of the system module compliant to the CommonJS System/1.0 specification.

  Beyond the standard, a "print" function and some properties for Narwhal compatibility are provided.

• test

• ringo/args

  A parser for command line options. This parser supports various option formats:

  -a -b -c (multiple short options)
  -abc (multiple short options combined into one)
  -a value (short option with value)
  -avalue (alternative short option with value)
  --option value (long option with value)
  --option=value (alternative long option with value)

• ringo/base64

  Base64 encoding and decoding for binary data and strings.

• ringo/buffer

  A Buffer class for composing strings.

• ringo/encoding

  Low-level support for character encoding and decoding.

• ringo/engine

  Provides access to the Rhino JavaScript engine.

• ringo/functional

  Function utilities.

• ringo/httpclient

  A scalable HTTP client that provides both synchronous and asynchronous modes of operation.

• ringo/httpserver

  A wrapper for the Jetty HTTP server.

• ringo/jsdoc

  Low level support for parsing JSDoc-style comments from JavaScript files.

• ringo/jsgi

  Low level JSGI adapter implementation.

• ringo/logging

  This module provides generic logging support for Ringo applications. It uses SLF4J or Apache log4j if either is detected in the classpath, and will fall back to java.util.logging otherwise.

  If the first argument passed to any of the logging methods is a string containing any number of curly bracket pairs ({}), the logger will interpret it as format string and use any following arguments to replace the curly bracket pairs. If an argument is an Error or Java Exception object, the logger will render a stack trace for it and append it to the log message.

• ringo/markdown

  A fast and extensible Markdown formatter.

• ringo/parser

  This module provides an interface to the Rhino parser.

• ringo/profiler

  A profiler for measuring execution time of JavaScript functions. Note that you need to run with optimization level -1 for profiling to work. Running the profiler on optimized code will produce no data.

• ringo/promise

  Allows to work with deferred values that will be resolved in the future.

• ringo/scheduler

  This module provides support for scheduling invocation of functions.

• ringo/shell

  provides functions to work with the Ringo shell.

• ringo/skin

  This module provides a flexible templating system.

• ringo/subprocess

  A module for spawning processes, connecting to their input/output/errput and returning their response codes.

• ringo/term

  A module for printing ANSI terminal escape sequences. This module provides a number of useful color and style constants, and a replacement for the print function optimized for styled output.

• ringo/webapp

• ringo/zip

  This module provides classes to uncompress zip files and streams.

• ringo/admin/create

  Script to create a new RingoJS web application.

• ringo/admin/install

  Download and install a RingoJS package from a zip URL

• ringo/admin/main

• ringo/middleware/basicauth

  Basic Authentication middleware. To apply authentication to parts of your website add this to your list of middlewares and pass the middleware function an object like this with the long string being a SHA1 digest of the user's password:

  var authConfig = {
      '/protected/path': {
          admin: "30b93f320076de1304c34673f9f524f7ea7db709"
      }
  };
  middleware = [
      require('ringo/middleware/basicauth').middleware(authConfig),
  ];

• ringo/middleware/error

  Middleware to catch errors and generate simple error pages.

• ringo/middleware/etag

  Middleware that supports conditional GET requests via ETag headers.

• ringo/middleware/gzip

  Middleware for on-the-fly GZip compression of response bodies.

• ringo/middleware/notfound

  Middleware for simple Not-Found pages.

• ringo/middleware/profiler

  Profiler middleware.

• ringo/middleware/responselog

• ringo/middleware/static

  Middleware for serving static resources.

• ringo/middleware/transaction

• ringo/skin/filters

  Implements some useful macro filters.

• ringo/skin/macros

• ringo/storage/filestore

• ringo/storage/googlestore

• ringo/storage/memstore

• ringo/storage/querysupport

• ringo/storage/storeutils

• ringo/utils/arrays

  Provides utility functions for working with JavaScript Arrays.

• ringo/utils/dates

  Adds useful functions for working with JavaScript Date objects.

• ringo/utils/debug

• ringo/utils/files

  A collection of file related utilities.

• ringo/utils/numbers

  Provides utility functions for working with JavaScript numbers.

• ringo/utils/objects

  Adds utility functions for working with JavaScript Objects

• ringo/utils/regexp

• ringo/utils/strings

  Adds useful methods to the JavaScript String type.

• ringo/webapp/async

  This module provides support for fully asynchronous, streaming HTTP responses. Asynchronous responses can be handled by the original thread handling a HTTP request, or any other thread. Note that streaming async responses are not JSGI compatible and therefore not passed through the JSGI middleware stack.

• ringo/webapp/continuation

• ringo/webapp/daemon

• ringo/webapp/env

  This module can be used to lookup the current JSGI request and config module in a web application.

• ringo/webapp/fileupload

• ringo/webapp/mime

• ringo/webapp/parameters

• ringo/webapp/request

  Adds convenience properties and methods to a JSGI 0.3 request object.

• ringo/webapp/response

  This module provides a Response helper classes for composing JSGI response objects. The Response class also features a number of static methods for composing special-purpose response objects.

• ringo/webapp/util

• ringo/webapp/websocket

  adds support for Websockets to Ringo webapps.