Class GLOBALS

Object
   |
   +--GLOBALS

class GLOBALS

add_event_handler

<static> function add_event_handler(<DOM:element> obj, <String> event, <function> handler)

Adds an event handler to a DOM node without replacing any existing handlers. The user's handler will be called after all previous handlers, and its return value will be propagated. Credit must be given to http://www.quirksmode.com for valuable browser information.

Parameters:
obj - The DOM node
event - The event name (e.g. 'click') or moniker (e.g., 'onclick')
handler - The handler to call; it will be passed the event object, and the 'this' object will be the DOM node on which the event occurred

Returns:
The function that is actually registered on the event is returned; it performs some cross-browser maintenance before calling the given handler

addTestResult

<static> void addTestResult(test, success, index)

Writes the result of running a test to the DOM.

alert_on_error

<static> void alert_on_error(source, msg)

One possible behavior on error: alert.

attach_handler

<static> void attach_handler(<DOM:element> obj, <function> handler)

Recursively attaches events to a DOM object.

Parameters:
obj - The DOM object
handler - The event handler -- it will be passed the cross- browser event object

bind_lens

<static> function bind_lens(<Lens> lens, <String> dom_id, <function> dom_update_callback, <int> polling)

Binds a lens to a given id in the document. It returns a callback that notifies the lens binding of new model values; it takes an optional callback to notify the caller of new model values due to DOM changes.

Parameters:
lens - The lens
dom_id - The id to bind to
dom_update_callback - The callback to call when the DOM changes to create a new model value; it will be called with the new value
polling - An optional argument setting the frequency in milliseconds to check for new DOM structure; the default is 5000

Returns:
A callback to provide the binding with new values

See:
- unbind_lens()

clone

<static> Object clone(o, as_array)

Clones an object or an array (shallowly); anything else is simply returned.

Parameters:
o - The value to be cloned
as_array - Set to true to force the argument to be treated as an array; the default is false

Returns:
A shallow copy of the object

createTestInfo

<static> Object createTestInfo(test, count_id, time_id, failures_id, prose)

Creates the structure for storing test results.

debugger_on_error

<static> void debugger_on_error(source, msg)

One possible behavior on error: start a debugger with the debugger keyword.

dom_obj

<static> Object dom_obj(o)

domify

<static> DOM:element domify(o)

Turns an object into a displayable DOM element. If the object is already a DOM node, nothing is done. Otherwise, a new text node is made out of the given value.

Parameters:
o - The object to put into the dom

Returns:
A DOM-ified version of the object

equal

<static> boolean equal(o1, o2)

Recursively tests equality of objects. equal(o, undefined) for any o.

Parameters:
o1 - First value to compare
o2 - Second value to compare

Returns:
true if o1 and o2 are recursively equal

get_dom_object

<static> DOM:element get_dom_object(<String> name, <boolean> strict)

Gets a DOM object in a portable/intelligent way. If the named object couldn't be found, then error is called.

Parameters:
name - The name of the DOM object; if name is already a DOM object, then it is simply returned
strict - Set to true to cause an error for failed lookups; the default is false

Returns:
The DOM element found

has_prop

<static> boolean has_prop(o, <String> p)

Determines whether p is a property of o. If o is not an object, then this function returns true for all p.

Parameters:
o - The value to test
p - The property to check for

Returns:
True if p in o

incrementTestCount

<static> void incrementTestCount(countSpan, success)

Updates a test count.

is_editable

<static> boolean is_editable(o)

A predicate for DOM objects which are editable, and which events must be caught for. This is, in particular, input elements matching input_nodes, the textarea element, and the select element.

Parameters:
o - Any object

Returns:
True if o has a meaningful onchange event (while some browsers have mixed onchange implementations, this includes checkboxes and radio buttons)

is_lens

<static> boolean is_lens(o)

Returns true if a given object is a lens. It tests this by 'duck typing' -- any object with get and putback properties that are functions is considered a lens.

Parameters:
o - Any object

Returns:
True if o is a lens

jsify

<static> Object jsify(<DOM:node> e, orig)

Turns a DOM element into a JavaScript object -- as best it can. This amounts to just turning text nodes into strings; beyond this, nothing is really done.

Parameters:
e - A DOM node

Returns:
A JavaScript object version of e

lens_c

<static> Contract lens_c(<Contract> get_c, <Contract> putback_c)

A contract for a lens object.

Parameters:
get_c - The contract for the get operation
putback_c - The contract for the putback operation

Returns:
A contract 'lens_c' that enforces get_c and putback_c

lens_constructor

<static> Contract lens_constructor()

A contract for a Lens-derived lens constructor, that enforces a calling convention, as well as get and putback contracts on the generated lens. Zero or more argument contracts are given, followed by a get contract and a putback contract.

Returns:
A contract for a lens constructor

log_on_error

<static> void log_on_error(source, msg)

One possible behavior on error: log the error to the Firebug console.

make_arith_lens

<static> Object make_arith_lens(<String> name, <function> op, <function> inv, <function> guard)

Generates and registers arithmetic lenses.

Parameters:
name - The lens to create
op - The operator
inv - Its inverse
guard - An optional guard over v and d, which can throw an error if v and d are somehow invalid for op and inv, e.g. would cause a divide-by-zero. Takes v, and d. For an example, see nonzero_v().

make_dom_node

<static> Object make_dom_node(<String> name, attribs, <Array> children)

Creates a DOM node.

Parameters:
name - The element name to create
attribs - An object mapping attribute names to values
children - The list of child nodes

make_lens_function

<static> function make_lens_function(<Lens> lens, <String> name)

Converts a lens constructor into a lens function.

Parameters:
lens - The lens constructor
name - The lens' name

Returns:
A lens-creating function -- it behaves like the constructor in every way, except that 'new' is not necessary

make_tag_lens

<static> Object make_tag_lens(<String> name, <String> placement)

Makes an LTag-derived lens. Similar in spirit to make_arith_lens(). Given the name, it creates the Lens constructor LNameTag and the lens function (a la make_lens_function()) name_tag.

The generated lenses take one of three calling conventions. Using LDivTag as an example, a DIV lens can be created in the standard LTag way: new LDivTag({ id: 'foo' }, ['First child']). It may also be called with an implicit LLayout: new LDivTag({ id: 'foo' }, 'lbl1', 'Foo: ', 'foo', new LPlus(5, 0), 'lbl2', 'Bar: ', 'bar', new LId()), where the arguments to LLayout are all of those after the attribute object. The third calling convention uses an implicit LSeq, like so: new LInputTag({ id: 'num' }, plus(5, 0)), where the value after the attribute object is a lens.

Lenses with a placement of 'const' will use LConstTag, which is a DOM-aware LConst.

Parameters:
name - The lens to create
placement - The default value for placement in LTag; should be either 'child', 'const', or an attribute name

merge_objects

<static> Object merge_objects(<Object> o1, <Object> o2, <function> error)

Merges two objects. If their properties aren't disjoint, than the procedure error is called, if it was provided.

Parameters:
o1 - The first object
o2 - The second object
error - Optional. Called if a property in o2 is also in o1

Returns:
The union of o1 and o2

nodify

<static> Object nodify(o, id)

Turns objects into span elements with ids.

Parameters:
o - The object
id - The id to use

nonzero_v

<static> void nonzero_v(v, d)

The guard used in LTimes and LDivide to prevent v==0 from occuring.

recordTestTime

<static> void recordTestTime(test, ms)

Writes the time taken running a series of tests to the DOM.

runTests

<static> void runTests()

Runs all tests in __tests.

scrub

<static> Object scrub(s)

set_error_handler

<static> void set_error_handler(<function> handler)

Sets the current error handler. Possible values include throw_on_error(), alert_on_error(), debugger_on_error(), and log_on_error(). Handlers will be passed a source identifier and an error message.

Parameters:
handler - An error handler: function (source, msg) { ... }

split_object

<static> Object split_object(<Object> o, <function> pred)

Splits an object in two: one whose properties all match a predicate, and the rest which fail.

Parameters:
o - The object to split
pred - The predicate over property names

Returns:
An object o where o.passed has passing properties and o.failed has failing properties.

throw_on_error

<static> void throw_on_error(source, msg)

One possible behavior on error: throw.

throws_e

<static> thunk throws_e(<function> f, <function> e_pred)

Tests that running f throws a value that satisfies e_pred.

Parameters:
f - The function to run
e_pred - A predicate matching the desired exception

Returns:
A test for whether f throws what is desired

unbind_lens

<static> Lens unbind_lens(<String> dom_id)

Unbinds a lens bound to the DOM id dom_id. If none is bound, an error is signalled.

Parameters:
dom_id - The DOM id to unbind

Returns:
The lens that was bound

See:
- bind_lens()

update_lens_prototype

<static> void update_lens_prototype(<String> name, <function> fun, <boolean> no_seq)

Updates the Lens prototype to have a method with the given name that calls the lens function (see make_lens_function()) fun as the second argument to an LSeq, e.g. if the lens foo is added to the prototype, then any lens may call l.foo(...) with meaning seq(l, foo(...)). Naturally, this behavior is not done for seq itself, by setting the third parameter to true.

This function should not be called directly, as #$L will call it for you.

Parameters:
name - The name of the lens
fun - The lens function, from make_lens_function()
no_seq - By default false, set to true to remove the implicit LSeq; instead, the lens (e.g. l in l.foo(...)) will be the first argument to fun, followed by ...