CERNY
This is the file that provides the core functionality of the Cerny.js library: interception, type checking, logging, dependency declaration, configuration and dictionaries.
To use the Cerny.js library this file must be included in your page. The configuration file (a copy of cerny.conf.js) must be included beforehand.
Some conventions used:
- If a current function or member is overwritten in a script, e.g. 'insertBefore', but will be referred to later, the new name of the member is composed of an underscore followed by the old name, e.g. '_insertBefore'.
- If a simple name is not possible due to keyword restrictions, the name is proceeded by an underscore, e.g. '_delete'.
- If a function takes arbitrarily many arguments, the documentation for these parameters must be called 'arguments'.
- If the documentation for a function does not specify a return value, the function returns undefined.
Uses
Used by
Functions
CloningException
Constructor for a cloning exception.
ContractViolation
Constructor for a contract violation.
Dictionary
Dictionary augmentor.
A dictionary is a mapping from terms to definitions. Definitions may contain variables, which are terms with curly braces. A term can be looked up in a dictionary to get its definition by
lookup
. Any string can be evaluated by
evaluate
.
A dictionary may contain a property
include
holding an array of strings denoting paths of dictionaries that will be included.
Logger
Create a logger. For every category there exists exactly one logger.
name
check
Check whether expr evaluates to true. If not throw a
CERNY.ContractViolation
. Only to be used in preconditions, postconditions and invariants.
clone
Clone an object. Works for most cases with some restrictions:
- Custom types may provide a clone method. This method will be called with no parameters and the result will be returned.
- Cyclic references cannot be handeled: infinite recursion!
- Partial cloning is supported, if something is referenced in the object tree that cannot be cloned, an message is printed on the console and the referring property is undefined.
dump
Dump a value for logging purposes. Returns the value of the variable followed by its type in braces. If the variable is a string, the value is enclosed by a single quote.
empty
The empty function.
evaluate
Evaluate a string. Replaces all variables in the string by its definitions in this dictionary.
getResource
Get a resource.
identity
Returns the argument.
intercept
Instrument methods of an object for interception. Can be called multiple times with the same effect, only depending on
CERNY.Configuration.Interception.active
or the passed interceptors.
This function does not work on the
window
object in IE.
If one overrides methods of an existing object, where interception was already installed with this function and use this function again to intercept the method, the old method will be installed and a information will be logged. This is unfortunate, but is necessary so that interception always has the same effect. Workaround: Use
CERNY.method
to attach the methods (best to both, but definitely when overriding) instead.
isPresent
Check whether an expression is present during runtime.
false
, if the string does not reference anything or the string references
undefined
joinFunctions
Join functions into one function. The new function returns the return value of the last function.
load
Load a script. This function is called in
require
. It has different implementations in various environments (browser, Rhino [RHI]). The default runtime enviornment is the browser.
loadData
Load some data, can be an object, an array, a function or a primitive value.
lookup
Lookup a term in this dictionary.
Before 1.5: Return undefined if a term is not found. Staring with 1.5: Throw error if a term is not found.
undefined
if the term is unknown
method
Attach a function as a method to an object. This allows to create arbitrarliy many functions around the actual function. It aims for separation of concerns. The interceptors are wrapped around the function starting with the last one. This allows a "natural order", when filling the array regarding dependency. So more basic interceptors (e.g.
LogIndenter
) are pushed first.
namespace
Create a namespace in
CERNY
. This function is inspired by the Yahoo! UI Library [YUI].
CERNY
object
Prototypal inheritance [DCP]. This alogorithm was developed by Douglas Crockford.
post
Specify the conditions that must be met in order to decide whether a function call was a success.
Postcondition is a function which is a sequence of calls to
CERNY.check
.
this
has the same meaning as in the function called.
Postcondition is passed the following parameters:
- the return value,
- the old version of the object the call is made on, and then
- the arguments of the call.
pre
Specify the conditions that must be met in order to decide whether a call to func can succeed. These conditions are collected in one function which is called the precondition. The precondition supports the author of a function in communicating the intent of the function to the consumer.
Precondition is a function which is a sequence of calls to
CERNY.check
.
Precondition is passed the arguments of the call and
this
has the same meaning as in the function called.
require
Check for the presence of expressions. Loads an expression by looking it up in the catalog.
Resolve external dependencies declared in the catalog.
signature
Specify the signature of a function. The types can be specified either by a string (
"boolean"
,
"string"
,
"number"
,
"object"
,
"function"
,
"undefined"
,
"null"
,
"any"
) or by a function, against which the actual value will be tested against with instanceof.
In the future it should be possible to specify an object as a type and the prototype chain is inspected for that object. Even more in the future it Cerny schemas could be used.
