RubyGems - gollum - Versions diffs - 1.3.1 → 1.4.2 - Mend

gollum 1.3.1 → 1.4.2

Potentially problematic release.

This version of gollum might be problematic. Click here for more details.

Files changed (688) hide show

data/lib/gollum/frontend/public/javascript/MathJax/docs/html/_sources/api/elementjax.txt DELETED Viewed

@@ -1,122 +0,0 @@
-.. _api-element-jax:
-****************************
-The MathJax.ElementJax Class
-****************************
-The element jax is the bridge between the input and output jax, and
-contains the data produced by the input jax needed by the output jax
-to display the results.  It is tied to the individual ``<script>`` tag
-that produced it, and is the object used by JavaScript programs to
-interact with the mathematics on the page.
-An element jax is stored in the ``jax.js`` file in a subdirectory of
-the ``jax/element`` directory, with the subdirectory name being the
-name of the element jax.  Currently, there is only one element jax
-class, the `mml` element jax, and it is stored in ``jax/element/mml``.
-The `MathJax.ElementJax` class is a subclass of the :ref:`MathJax Jax
-<api-jax>` class, and inherits the properties and methods of that
-class.  Those listed below are the additional or overridden ones from
-that class.
-Class Properties
-================
-.. describe:: name
-    The name of the jax.
-.. describe:: version
-    The version number of the jax.
-.. describe:: directory
-    The directory where the jax files are stored (e.g., ``"[MathJax]/jax/element/mml"``);
-Instance Properties
-===================
-.. describe:: inputJax
-    A reference to the input jax that created the element.
-.. describe:: outputJax
-    A reference to the output jax that has processed this element.
-.. describe:: inputID
-    The DOM `id` of the ``<script>`` tag that generated this element
-    (if it doesn't have one initially, the MathJax hub will supply
-    one).  Note that this is not a reference to the element itself;
-    that element will have a reference to this element jax, and if
-    `inputID` were a reference back, that would cause a reference
-    loop, which some browsers would not free properly during trash
-    collection, thus causing a memory leak.
-.. describe:: originalText
-    A string indicating the original input text that was processed for
-    this element.
-.. describe:: mimeType
-    The MIME-type of the element jax (`jax/mml` in the case of an
-    `mml` element jax).
-Other data specific to the element jax subclass may also appear here.
-Methods
-=======
-.. Method:: Text(text[,callback])
-    Sets the input text for this element to the given text and
-    reprocesses the mathematics.  (I.e., update the equation to the
-    new one given by `text`).  When the processing is complete, the
-    `callback`, if any, is called.
-    :Parameters:
-        - **text** --- the new mathematic source string for the element
-	- **callback** --- the callback specification
-    :Returns: the callback object
-.. Method:: Reprocess([callback])
-    :noindex:
-    Remove the output and produce it again.  This may be necessary if
-    there are changes to the CSS styles that would affect the layout
-    of the mathematics, for example.  The `callback`, if any, is
-    called when the process completes.
-    :Parameters:
-	- **callback** --- the callback specification
-    :Returns: the callback object
-.. Method:: Remove()
-    :noindex:
-    Removes the output for this element from the web page (but does
-    not remove the original ``<script>``).  The ``<script>`` will be
-    considered unprocessed, and the next call to
-    :meth:`MathJax.hub.Typeset()` will re-display it.
-    :Returns: ``null``
-.. Method:: SourceElement()
-    Returns a reference to the original ``<script>`` DOM element
-    associated to this element jax.
-    :Returns: the ``<script>`` element
-Output jax may add new methods to the base element jax class to
-perform exporting to other formats.  For example, a MathML output jax
-could add ``toMathML()``, or an accessibility output jax could add
-``toAudible()``.  These could be made available via the MathJax
-contextual menu.

data/lib/gollum/frontend/public/javascript/MathJax/docs/html/_sources/api/html.txt DELETED Viewed

@@ -1,122 +0,0 @@
-.. _api-html:
-***********************
-The MathJax.HTML Object
-***********************
-The ``MathJax.HTML`` object provides routines for creating HTML
-elements and adding them to the page, and int particular, it contains
-the code that processes MathJax's :ref:`HTML snippets <html-snippets>`
-and turns them into actual DOM objects.  It also implements the
-methods used to manage the cookies used by MathJax.
-Properties
-==========
-.. describe:: Cookie.prefix: "mjx"
-    The prefix used for names of cookies stored by MathJax.
-.. describe:: Cookie.expires: 365
-    The expiration time (in days) for cookies created by MathJax.
-Methods
-=======
-.. method:: Element(type[,attributes[,contents]])
-    Creates a DOM element of the given type.  If `attributes` is
-    non-``null``, it is an object that contains `key:value` pairs of
-    attributes to set for the newly created element.  If `contents` is
-    non-``null``, it is an :ref:`HTML snippet <html-snippets>` that
-    describes the contents to create for the element.  For example
-    .. code-block:: javascript
-        var div = MathJax.HTML.Element(
-	  "div",
-	  {id: "MathDiv", style:{border:"1px solid", padding:"5px"}},
-	  ["Here is math: $x+1$",["br"],"and a display $$x+1\\over x-1$$"]
-	);
-    :Parameters:
-        - **type** --- node type to be created
-        - **attributes** --- object specifying attributes to set
-        - **contents** --- HTML snippet representing contents of node
-    :Returns: the DOM element created
-.. method:: addElement(parent,type[,attributes[,content]])
-    Creates a DOM element and appends it to the `parent` node
-    provided.  It is equivalent to
-    .. code-block:: javascript
-        parent.appendChild(MathJax.HTML.Element(type,attributes,content))
-    :Parameters:
-        - **parent** --- the node where the element will be added
-        - **attributes** --- object specifying attributes to set
-        - **contents** --- HTML snippet representing contents of node
-    :Returns: the DOM element created
-.. method:: TextNode(text)
-    Creates a DOM text node with the given text as its content.
-    :Parameters:
-        - **text** --- the text for the node
-    :Returns: the new text node
-.. method:: addText(parent,text)
-    Creates a DOM text node with the given text and appends it to the
-    `parent` node.
-    :Parameters:
-        - **parent** --- the node where the text will be added
-        - **text** --- the text for the new node
-    :Returns: the new text node
-.. describe:: Cookie.Set(name,data)
-    Creates a MathJax cookie using the ``MathJax.HTML.Cookie.prefix``
-    and the `name` as the cookie name, and the `key:value` pairs in
-    the `data` object as the data for the cookie.  For example,
-    .. code-block:: javascript
-        MathJax.HTML.Cookie.Set("test",{x:42, y:"It Works!"});
-    will create a cookie named "mjx:test" that stores the values of
-    ``x`` and ``y`` provided in the `data` object.  This data can be
-    retrieved using the :meth:`MathJax.HTML.Cookie.Get()` method
-    discussed below.
-    :Parameters:
-        - **name** --- the name that identifies the coookie
-        - **data** --- object containing the data to store in the cookie
-    :Returns: ``null``
-.. describe:: Cookie.Get(name[,obj])
-    Looks up the data for the cookie named `name` and merges the data
-    into the given `obj` object, or returns a new object containing
-    the data.  For instance, given the cookie stored by the example
-    above,
-    .. code-block:: javascript
-        var data = MathJax.HTML.Cookie.Get("test");
-    would set ``data`` to ``{x:42, y:"It Works!"}``, while
-    .. code-block:: javascript
-        var data = {x:10, z:"Safe"};
-	MathJax.HTML.Cookie.Get("test",data);
-    would leave ``data`` as ``{x:42, y:"It Works!", z:"Safe"}``.

data/lib/gollum/frontend/public/javascript/MathJax/docs/html/_sources/api/hub.txt DELETED Viewed

@@ -1,330 +0,0 @@
-.. _api-hub:
-**********************
-The MathJax.Hub Object
-**********************
-The MathJax Hub, `MathJax.Hub`, is the main control structure for
-MathJax.  It is where input and output :term:`jax` are tied together,
-and it is what handles processing of the MathJax ``<script>`` tags.
-Processing of the mathematics on the page may require external files
-to be loaded (when the mathematics includes less common functionality,
-for example, that is defined in an extension file), and since file
-loading is asynchronous, a number of the methods below may return
-before their actions are completed.  For this reason, they include
-callback functions that are called when the action completes.  These
-can be used to synchronize actions that require the mathematics to be
-completed before those action occur. See the :ref:`Using Callbacks
-<using-callbacks>` documentation for more details.
-Properties
-==========
-.. describe:: config: { ... }
-    This holds the configuration parameters for MathJax.  Set these
-    values using :meth:`MathJax.Hub.Config()` described below.  The
-    options and their default values are given in the :ref:`Core
-    Options <configure-hub>` reference page.
-.. describe:: processUpdateTime: 500
-    The minimum time (in milliseconds) between updates of the
-    "Processing Math" message.
-.. describe:: signal
-    The hub processing signal (tied to the
-    :meth:`MathJax.Hub.Register.MessageHook()` method).
-.. describe:: Browser
-    The name of the browser as determined by MathJax.  It will be one
-    of ``Firefox``, ``Safari``, ``Chrome``, ``Opera``, ``MSIE``,
-    ``Konqueror``, or ``unkown``.  This is actually an object with
-    additional properties and methods concerning the browser:
-    .. describe:: version
-        The browser version number, e.g., ``"4.0"``
-    .. describe:: isMac and isPC
-        These are boolean values that indicate whether the browser is
-        running on a Macintosh computer or a Windows computer.  They
-        will both be ``false`` for a Linux computer
-    .. describe:: isForefox, isSafari, isChrome, isOpera, isMSIE, isKonqueror
-        These are ``true`` when the browser is the indicated one, and
-        ``false`` otherwise.
-    .. describe:: versionAtLeast(version)
-        This tests whether the browser version is at least that given
-        in the `version` string.  Note that you can not simply do a
-        numeric comparison, as version 4.10 should be considered later
-        than 4.9, for example.  Similarly, 4.10 is different from 4.1,
-        for instance.
-    .. describe:: Select(choices)
-        This lets you perform browser-specific functions.  Here,
-        `choices` is an object whose properties are the names of the
-        browsers and whose values are the functions to be performed.
-        Each function is passed one parameter, which is the
-        ``MathJax.Hub.Browser`` object.  You do not need to include
-        every browser as one of your choices (only those for which you
-        need to do special processing.  For example:
-	.. code-block:: javascript
-	    MathJax.Hub.Browser.Select(
-	      MSIE: function (browser) {
-	        if (browser.versionAtLeast("8.0")) {... do version 8 stuff ... }
-		... do general MSIE stuff ...
-	      },
-	      Firefox: function (browser) {
-	        if (browser.isMac) {... do Mac stuff ... }
-		... do general Firefox stuff
-	      }
-	    );
-Methods
-=======
-.. Method:: Config(options)
-    Sets the configuration options (stored in ``MathJax.Hub.config``)
-    to the values stored in the `options` object.  See
-    :ref:`Configuring MathJax <configuration>` for details on how this
-    is used and the options that you can set.
-    :Parameters:
-        - **options** --- object containing options to be set
-    :Returns: ``null``
-.. describe:: Register.PreProcessor(callback)
-    Used by preprocessors to register themselves with MathJax so that
-    they will be called during the :meth:`MathJax.Hub.PreProcess()`
-    action.
-    :Parameters:
-        - **callback** ---  the callback specification for the preprocessor
-    :Returns: ``null``
-.. describe:: Register.MessageHook(type,callback)
-    Registers a listener for a particular message being sent to the
-    hub processing signal (where `PreProcessing`, `Processing`, and
-    `New Math` messages are sent).  When the message equals the
-    `type`, the `callback` will be called with the message as its
-    parameter.
-    :Parameters:
-        - **type** --- a string indicating the message to look for
-        - **callback** --- a callback specification
-    :Returns: ``null``
-.. describe:: Register.StartupHook(type,callback)
-    Registers a listener for a particular message being sent to the
-    startup signal (where initialization and component startup
-    messages are sent).  When the message equals the `type`, the
-    `callback will be called with the message as its parameter.
-    See the :ref:`Using Signals <using-signals>` dcocumentation for
-    more details.
-    :Parameters:
-        - **type** --- a string indicating the message to look for
-        - **callback** --- a callback specification
-    :Returns: ``null``
-.. describe:: Register.LoadHook(file,callback)
-    Registers a callback to be called when a particular file is
-    completely loaded and processed.  (The callback is called when the
-    file makes its :meth:`MathJax.Ajax.loadComplete()` call.) The
-    `file` should be the complete file name, e.g.,
-    ``"[MathJax]/config/MathJax.js"``.
-    :Parameters:
-        - **file** --- the name of the file to wait for
-        - **callback** --- a callback specification
-    :Returns: the callback object
-.. Method:: Queue(callback,...)
-    :noindex:
-    Pushes the given callbacks onto the main MathJax command queue.
-    This synchronizes the commands with MathJax so that they will be
-    performed in the proper order even when some run asynchronously.
-    See :ref:`Using Queues <using-queues>` for more details about how
-    to use queues, and the MathJax queue in particular.  You may
-    supply as many `callback` specifications in one call to the
-    :meth:`Queue()` method as you wish.
-    :Parameters:
-        - **callback** --- a callback specification
-    :Returns: the callback object for the last callback added to the queue
-.. Method:: Typeset([element[,callback]])
-    Calls the preprocessors on the given element, and then typesets
-    any math elements within the element.  If no `element` is
-    provided, the whole document is processed.  The `element` is
-    either the DOM `id` of the element, or a reference to the DOM
-    element itself.  The `callback` is called when the process is
-    complete.  See the :ref:`Modifying Math <typeset-math>` section
-    for details of how to use this method properly.
-    :Parameters:
-        - **element** --- the element whose math is to be typeset
-        - **callback** --- the callback specification
-    :Returns: the callback object
-.. method:: PreProcess([element[,callback]])
-    Calls the loaded preprocessors on the entire document, or on the
-    given DOM element.  The `element` is either the DOM `id` of the
-    element, or a reference to the DOM element itself.  The `callback`
-    is called when the processing is complete.
-    :Parameters:
-        - **element** --- the element to be preprocessed
-        - **callback** --- the callback specification
-    :Returns: the callback object
-.. method:: Process([element[,callback]])
-    Scans either the entire document or a given DOM `element` for
-    MathJax ``<script>`` tags and processes the math those tags
-    contain.  The `element` is either the DOM `id` of the element to
-    scan, or a reference to the DOM element itself.  The `callback` is
-    called when the processing is complete.
-    :Parameters:
-        - **element** --- the element to be processed
-        - **callback** --- the callback specification
-    :Returns: the callback object
-.. method:: Update([element[,callback]])
-    Scans either the entire document or a given DOM element for
-    mathematics that has changed since the last time it was processed,
-    or is new, and typesets the mathematics they contain.  The
-    `element` is either the DOM `id` of the element to scan, or a
-    reference to the DOM element itself.  The `callback` is called
-    when the processing is complete.
-    :Parameters:
-        - **element** --- the element to be updated
-        - **callback** --- the callback specification
-    :Returns: the callback object
-.. method:: Reprocess([element[,callback]])
-    Removes any typeset mathematics from the document or DOM
-    element, and then processes the mathematics again,
-    re-typesetting everything.  This may be necessary, for example, if
-    the CSS styles have changed and those changes would affect the
-    mathematics.  The `element` is either the DOM `id` of the element
-    to scan, or a reference to the DOM element itself.  The `callback`
-    is called when the processing is complete.
-    :Parameters:
-        - **element** --- the element to be reprocessed
-        - **callback** --- the callback specification
-    :Returns: the callback object
-.. method:: getAllJax([element])
-    Returns a list of all the element jax in the document or a
-    specific DOM element.  The `element` is either the DOM `id` of the
-    element, or a reference to the DOM element itself.
-    :Parameters:
-        - **element** --- the element to be searched
-    :Returns: array of `element jax` objects
-.. method:: getJaxByType(type[,element])
-    Returns a list of all the element jax of a given MIME-type in the
-    document or a specific DOM element.  The `element` is either the
-    DOM `id` of the element to search, or a reference to the DOM
-    element itself.
-    :Parameters:
-        - **type** --- MIME-type of `element jax` to find
-        - **element** --- the element to be searched
-    :Returns: array of `element jax` objects
-.. method:: getJaxByInputType(type[,element])
-    Returns a list of all the element jax associated with input
-    ``<script>`` tags with the given MIME-type within the given DOM
-    element or the whole document.  The `element` is either the DOM
-    `id` of the element to search, or a reference to the DOM element
-    itself.
-    :Parameters:
-        - **type** --- MIME-type of input (e.g., ``"math/tex"``)
-        - **element** --- the element to be searched
-    :Returns: array  of `element jax` objects
-.. method:: getJaxFor(element)
-    Returns the element jax associated with a given DOM
-    element.  If the element does not have an associated element jax,
-    ``null`` is returned.  The `element` is either the DOM `id` of the
-    element, or a reference to the DOM element itself.
-    :Parameters:
-        - **element** --- the element whose element jax is required
-    :Returns: `element jax` object or ``null``
-.. method:: isJax(element)
-    Returns ``0`` if the element is not a ``<script>`` that can be
-    processed by MathJax or the result of an output jax, returns ``-1``
-    if element is an unprocessed ``<script>`` tag that could be
-    handled by MathJax, and returns ``1`` if element is a processed
-    ``<script>`` tag or an element that is the result of an output jax.
-    :Parameters:
-        - **element** --- the element to inspect
-    :Returns: integer (-1, 0, 1)
-.. Method:: Insert(dst,src)
-    Inserts data from the `src` object into the `dst` object.  The
-    `key:value` pairs in `src` are (recursively) copied into `dst`, so
-    that if `value` is itself an object, its contents is copied into
-    the corresponding object in `dst`.  That is, objects within `src`
-    are merged into the corresponding objects in `dst` (they don't
-    replace them).
-    :Parameters:
-        - **dst** --- the destination object
-        - **src** --- the source object
-    :Returns: the modified destination object
-.. Method:: formatError(script,error)
-    This is called when an internal error occurs during the processing
-    of a math element (i.e., an error in the MathJax code itself).
-    The `script` is a reference to the ``<script>`` tag where the
-    error occurred, and `error` is the ``Error`` object for the error.
-    The default action is to insert an HTML snippet at the location of
-    the script, but this routine can be overriden durring MathJax
-    configuration in order to perform some other action.
-    ``MathJax.Hub.lastError`` holds the ``error`` value of the last
-    error on the page.
-    :Parameters:
-        - **script** --- the ``<script>`` tag causing the error
-        - **error** --- the ``Error`` object for the error
-    :Returns: ``null``