RubyGems - gollum - Versions diffs - 1.1.1 → 1.2.0 - Mend

gollum 1.1.1 → 1.2.0

Potentially problematic release.

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

Files changed (765) hide show

data/lib/gollum/frontend/public/javascript/MathJax/test/sample-dynamic.html ADDED

@@ -0,0 +1,54 @@
+<html>
+<head>
+<title>MathJax Dynamic Math Test Page</title>
+<!-- Copyright (c) 2010 Design Science, Inc. -->
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" >
+<script src="../MathJax.js">
+  MathJax.Hub.Config({
+    extensions: ["tex2jax.js"],
+    jax: ["input/TeX","output/HTML-CSS"],
+    tex2jax: {inlineMath: [["$","$"],["\\(","\\)"]]}
+  });
+</script>
+</head>
+<body>
+<script>
+  //
+  //  Use a closure to hide the local variables from the
+  //  global namespace
+  //
+  (function () {
+    var QUEUE = MathJax.Hub.queue;  // shorthand for the queue
+    var math = null;                // the element jax for the math output.
+    //
+    //  Get the element jax when MathJax has produced it.
+    //
+    QUEUE.Push(function () {
+      math = MathJax.Hub.getAllJax("MathOutput")[0];
+    });
+    //
+    //  The onchange event handler that typesets the
+    //  math entered by the user
+    //
+    window.UpdateMath = function (TeX) {
+      QUEUE.Push(["Text",math,"\\displaystyle{"+TeX+"}"]);
+    }
+  })();
+</script>
+Type some TeX code and press RETURN:<br/>
+<input id="MathInput" size="50" onchange="UpdateMath(this.value)" />
+<p>
+<div id="MathOutput">
+You typed: ${}$
+</div>
+</body>
+</html>

data/lib/gollum/frontend/public/javascript/MathJax/test/sample-mml.html ADDED

@@ -0,0 +1,44 @@
+<html>
+<head>
+<title>MathJax MathML Test Page</title>
+<!-- Copyright (c) 2010 Design Science, Inc. -->
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" >
+<script src="../MathJax.js">
+  MathJax.Hub.Config({
+    extensions: ["mml2jax.js"],
+    jax: ["input/MathML","output/HTML-CSS"]
+  });
+</script>
+</head>
+<body>
+When <math><mi>a</mi><mo>&#x2260;</mo><mn>0</mn></math>,
+there are two solutions to <math>
+  <mi>a</mi><msup><mi>x</mi><mn>2</mn></msup>
+  <mo>+</mo> <mi>b</mi><mi>x</mi>
+  <mo>+</mo> <mi>c</mi> <mo>=</mo> <mn>0</mn>
+</math> and they are
+<math mode="display">
+  <mi>x</mi> <mo>=</mo>
+  <mrow>
+    <mfrac>
+      <mrow>
+        <mo>&#x2212;</mo>
+        <mi>b</mi>
+        <mo>&#x00B1;</mo>
+        <msqrt>
+          <msup><mi>b</mi><mn>2</mn></msup>
+          <mo>&#x2212;</mo>
+          <mn>4</mn><mi>a</mi><mi>c</mi>
+        </msqrt>
+      </mrow>
+      <mrow> <mn>2</mn><mi>a</mi> </mrow>
+    </mfrac>
+  </mrow>
+  <mtext>.</mtext>
+</math>
+</body>
+</html>

data/lib/gollum/frontend/public/javascript/MathJax/test/sample-signals.html ADDED

@@ -0,0 +1,121 @@
+<html>
+<head>
+<title>MathJax Signals Test Page</title>
+<!-- Copyright (c) 2010 Design Science, Inc. -->
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" >
+<!--
+ | This example shows how to use MathJax's signal mechanism to find out
+ | about what MathJax is doing, and to hook into various events as they
+ | occur.
+-->
+<script src="../MathJax.js">
+  //
+  //  Configure MathJax
+  //
+  MathJax.Hub.Config({
+    extensions: ["tex2jax.js"],
+    jax: ["input/TeX","output/HTML-CSS"],
+    tex2jax: {inlineMath: [["$","$"],["\\(","\\)"]]}
+  });
+  //
+  //  Display a message that we are in the configuration code
+  //   (The Message function is not yet defined when this code
+  //    runs, so we can't use that here.  Post a signal
+  //    of our own, so it will be displayed along with all
+  //    the other signals).
+  //
+  MathJax.Hub.Startup.signal.Post("*** In Startup Configuration code ***");
+  //
+  //  When the "onLoad" message is posted, display a message.
+  //    (Since this hook is registered before the ones in the main body
+  //     below, it runs before the code to print the "Startup: onLoad"
+  //     message, so this message shows up first in the output.)
+  //
+  MathJax.Hub.Register.StartupHook("onLoad",function () {
+    Message("*** The onLoad handler has run, page is ready to process ***");
+  });
+  //
+  //  This will be performed after MathJax has completed its
+  //  setup and typesetting run, which have already been
+  //  pushed onto the queue.
+  //    (Since the Message function isn't defined yet when this code
+  //     runs, we need to enclose it in a function so it will be
+  //     looked up later when it is defined.)
+  //
+  MathJax.Hub.Queue(function () {Message("*** MathJax is done ***")});
+</script>
+<style>
+  .output {
+    background-color: #F0F0F0;
+    border-top: 1px solid;
+    border-bottom: 1px solid;
+    padding: 3px 1em;
+  }
+</style>
+</head>
+<body>
+When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are
+$$x = {-b \pm \sqrt{b^2-4ac} \over 2a}.$$
+Messages about mathematics:
+<pre id="MathMessages" class="output">
+</pre>
+All Messages:
+<pre id="AllMessages" class="output">
+</pre>
+<script>
+(function () {
+  //
+  //  The output areas
+  //
+  var math = document.getElementById("MathMessages");
+  var all = document.getElementById("AllMessages");
+  //
+  //  A function to display messages in the "AllMessages" area.
+  //  We make it global so it can be used in the startup code above.
+  //
+  window.Message = function (message) {
+    MathJax.HTML.addText(all,message);
+    MathJax.HTML.addElement(all,"br");
+  };
+  //
+  //  Find out about "New Math" messages from the Hub and display them.
+  //    (Look up the TeX code for each new math element)
+  //
+  MathJax.Hub.Register.MessageHook("New Math",function (message) {
+    var script = MathJax.Hub.getJaxFor(message[1]).SourceElement();
+    MathJax.HTML.addText(math,message.join(" ")+": '"+script.text+"'");
+    MathJax.HTML.addElement(math,"br");
+  });
+  //
+  //  Find out about ALL startup and hub messages
+  //
+  MathJax.Hub.Startup.signal.Interest(function (message) {Message("Startup: "+message)});
+  MathJax.Hub.signal.Interest(function (message) {Message("Hub: "+message)});
+  //
+  //  Since signals are remembered, registering an interest will cause
+  //  use to receive all the past signals as well as new ones.
+  //  This marks the point were the above routines were called.
+  //
+  Message("##### events above this have already occurred #####");
+})();
+</script>
+</body>
+</html>

data/lib/gollum/frontend/public/javascript/MathJax/test/sample-tex.html ADDED

@@ -0,0 +1,22 @@
+<html>
+<head>
+<title>MathJax TeX Test Page</title>
+<!-- Copyright (c) 2010 Design Science, Inc. -->
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" >
+<script src="../MathJax.js">
+  MathJax.Hub.Config({
+    extensions: ["tex2jax.js"],
+    jax: ["input/TeX","output/HTML-CSS"],
+    tex2jax: {inlineMath: [["$","$"],["\\(","\\)"]]}
+  });
+</script>
+</head>
+<body>
+When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are
+$$x = {-b \pm \sqrt{b^2-4ac} \over 2a}.$$
+</body>
+</html>

data/lib/gollum/frontend/public/javascript/MathJax/test/sample-tex2mml.html ADDED

@@ -0,0 +1,23 @@
+<html>
+<head>
+<title>MathJax TeX input with MathML output Test Page</title>
+<!-- Copyright (c) 2010 Design Science, Inc. -->
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" >
+<script src="../MathJax.js">
+  MathJax.Hub.Config({
+    config: ["MMLorHTML.js"],
+    extensions: ["tex2jax.js"],
+    jax: ["input/TeX"],
+    tex2jax: {inlineMath: [["$","$"],["\\(","\\)"]]}
+  });
+</script>
+</head>
+<body>
+When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are
+$$x = {-b \pm \sqrt{b^2-4ac} \over 2a}.$$
+</body>
+</html>

data/lib/gollum/frontend/public/javascript/editor/gollum.editor.js ADDED

@@ -0,0 +1,1084 @@
+/**
+ *  gollum.editor.js
+ *  A jQuery plugin that creates the Gollum Editor.
+ *
+ *  Usage:
+ *  $.GollumEditor(); on DOM ready.
+ */
+(function($) {
+  // Editor options
+  var DefaultOptions = {
+    MarkupType: 'markdown',
+    EditorMode: 'code',
+    NewFile: false,
+    HasFunctionBar: true,
+    Debug: false,
+    NoDefinitionsFor: []
+  };
+  var ActiveOptions = {};
+  /**
+   *  $.GollumEditor
+   *
+   *  You don't need to do anything. Just run this on DOM ready.
+   */
+  $.GollumEditor = function( IncomingOptions ) {
+    ActiveOptions = $.extend( DefaultOptions, IncomingOptions );
+    debug('GollumEditor loading');
+    if ( EditorHas.baseEditorMarkup() ) {
+      if ( EditorHas.titleDisplayed() ) {
+        $('#gollum-editor-title-field').addClass('active');
+      }
+      if ( EditorHas.editSummaryMarkup() ) {
+        $.GollumEditor.Placeholder.add($('#gollum-editor-edit-summary input'));
+        $('#gollum-editor form[name="gollum-editor"]').submit(function( e ) {
+          e.preventDefault();
+          $.GollumEditor.Placeholder.clearAll();
+          debug('submitting');
+          $(this).unbind('submit');
+          $(this).submit();
+        });
+      }
+      if ( EditorHas.collapsibleInputs() ) {
+        $('#gollum-editor .collapsed a.button, ' +
+          '#gollum-editor .expanded a.button').click(function( e ) {
+          e.preventDefault();
+          $(this).parent().toggleClass('expanded');
+          $(this).parent().toggleClass('collapsed');
+        });
+      }
+      if ( EditorHas.previewButton() ) {
+        var formAction =
+        $('#gollum-editor #gollum-editor-preview').click(function() {
+          // make a dummy form, submit to new target window
+          // get form fields
+          var oldAction = $('#gollum-editor form').attr('action');
+          var $form = $($('#gollum-editor form').get(0));
+          $form.attr('action', this.href);
+          $form.attr('target', '_blank');
+          $form.submit();
+          $form.attr('action', oldAction);
+          $form.removeAttr('target');
+          return false;
+        });
+      }
+      // Initialize the function bar by loading proper definitions
+      if ( EditorHas.functionBar() ) {
+        var htmlSetMarkupLang =
+          $('#gollum-editor-body').attr('data-markup-lang');
+        if ( htmlSetMarkupLang ) {
+          ActiveOptions.MarkupType = htmlSetMarkupLang;
+        }
+        // load language definition
+        LanguageDefinition.setActiveLanguage( ActiveOptions.MarkupType );
+        if ( EditorHas.formatSelector() ) {
+          FormatSelector.init(
+            $('#gollum-editor-format-selector select') );
+        }
+        if ( EditorHas.help() ) {
+          $('#gollum-editor-help').hide();
+          $('#gollum-editor-help').removeClass('jaws');
+        }
+      }
+      // EditorHas.functionBar
+    }
+    // EditorHas.baseEditorMarkup
+  };
+  /**
+   *  $.GollumEditor.defineLanguage
+   *  Defines a set of language actions that Gollum can use.
+   *  Used by the definitions in langs/ to register language definitions.
+   */
+  $.GollumEditor.defineLanguage = function( language_name, languageObject ) {
+    if ( typeof languageObject == 'object' ) {
+      LanguageDefinition.define( language_name, languageObject );
+    } else {
+      debug('GollumEditor.defineLanguage: definition for ' + language_name +
+            ' is not an object');
+    }
+  };
+  /**
+   *  debug
+   *  Prints debug information to console.log if debug output is enabled.
+   *
+   *  @param  mixed  Whatever you want to dump to console.log
+   *  @return void
+   */
+  var debug = function(m) {
+    if ( ActiveOptions.Debug &&
+         typeof console != 'undefined' ) {
+      console.log( m );
+    }
+  };
+  /**
+   *  LanguageDefinition
+   *  Language definition file handler
+   *  Loads language definition files as necessary.
+   */
+  var LanguageDefinition = {
+    _ACTIVE_LANG: '',
+    _LOADED_LANGS: [],
+    _LANG: {},
+    /**
+     *  Defines a language
+     *
+     *  @param name string  The name of the language
+     *  @param name object  The definition object
+     */
+    define: function( name, definitionObject ) {
+      LanguageDefinition._ACTIVE_LANG = name;
+      LanguageDefinition._LOADED_LANGS.push( name );
+      LanguageDefinition._LANG[name] = definitionObject;
+    },
+    getActiveLanguage: function() {
+      return LanguageDefinition._ACTIVE_LANG;
+    },
+    setActiveLanguage: function( name ) {
+      if ( !LanguageDefinition.isLoadedFor(name) ) {
+        LanguageDefinition._ACTIVE_LANG = null;
+        LanguageDefinition.loadFor( name, function(x, t) {
+          if ( t != 'success' ) {
+            debug('Failed to load language definition for ' + name);
+            // well, fake it and turn everything off for this one
+            LanguageDefinition.define( name, {} );
+          }
+          // update features that rely on the language definition
+          if ( EditorHas.functionBar() ) {
+            FunctionBar.refresh();
+          }
+          if ( LanguageDefinition.isValid() && EditorHas.formatSelector() ) {
+            FormatSelector.updateSelected();
+          }
+        } );
+      } else {
+        LanguageDefinition._ACTIVE_LANG = name;
+        FunctionBar.refresh();
+      }
+    },
+    /**
+     *  gets a definition object for a specified attribute
+     *
+     *  @param  string  attr    The specified attribute.
+     *  @param  string  specified_lang  The language to pull a definition for.
+     *  @return object if exists, null otherwise
+     */
+    getDefinitionFor: function( attr, specified_lang ) {
+      if ( !specified_lang ) {
+        specified_lang = LanguageDefinition._ACTIVE_LANG;
+      }
+      if ( LanguageDefinition.isLoadedFor(specified_lang) &&
+           LanguageDefinition._LANG[specified_lang][attr] &&
+           typeof LanguageDefinition._LANG[specified_lang][attr] == 'object' ) {
+        return LanguageDefinition._LANG[specified_lang][attr];
+      }
+      return null;
+    },
+    /**
+     *  loadFor
+     *  Asynchronously loads a definition file for the current markup.
+     *  Definition files are necessary to use the code editor.
+     *
+     *  @param  string  markup_name  The markup name you want to load
+     *  @return void
+     */
+    loadFor: function( markup_name, on_complete ) {
+      // Keep us from hitting 404s on our site, check the definition blacklist
+      if ( ActiveOptions.NoDefinitionsFor.length ) {
+        for ( var i=0; i < ActiveOptions.NoDefinitionsFor.length; i++ ) {
+          if ( markup_name == ActiveOptions.NoDefinitionsFor[i] ) {
+            // we don't have this. get out.
+            if ( typeof on_complete == 'function' ) {
+              on_complete( null, 'error' );
+              return;
+            }
+          }
+        }
+      }
+      // attempt to load the definition for this language
+      var script_uri = '/javascript/editor/langs/' + markup_name + '.js';
+      $.ajax({
+                url: script_uri,
+                dataType: 'script',
+                complete: function( xhr, textStatus ) {
+                  if ( typeof on_complete == 'function' ) {
+                    on_complete( xhr, textStatus );
+                  }
+                }
+            });
+    },
+    /**
+     *  isLoadedFor
+     *  Checks to see if a definition file has been loaded for the
+     *  specified markup language.
+     *
+     *  @param  string  markup_name   The name of the markup.
+     *  @return boolean
+     */
+    isLoadedFor: function( markup_name ) {
+      if ( LanguageDefinition._LOADED_LANGS.length === 0 ) {
+        return false;
+      }
+      for ( var i=0; i < LanguageDefinition._LOADED_LANGS.length; i++ ) {
+        if ( LanguageDefinition._LOADED_LANGS[i] == markup_name ) {
+          return true;
+        }
+      }
+      return false;
+    },
+    isValid: function() {
+      return ( LanguageDefinition._ACTIVE_LANG &&
+               typeof LanguageDefinition._LANG[LanguageDefinition._ACTIVE_LANG] ==
+               'object' );
+    }
+  };
+  /**
+   *  EditorHas
+   *  Various conditionals to check what features of the Gollum Editor are
+   *  active/operational.
+   */
+  var EditorHas = {
+    /**
+     *  EditorHas.baseEditorMarkup
+     *  True if the basic editor form is in place.
+     *
+     *  @return boolean
+     */
+    baseEditorMarkup: function() {
+      return ( $('#gollum-editor').length &&
+               $('#gollum-editor-body').length );
+    },
+    /**
+     *  EditorHas.collapsibleInputs
+     *  True if the editor contains collapsible inputs for things like the
+     *  sidebar or footer, false otherwise.
+     *
+     *  @return boolean
+     */
+    collapsibleInputs: function() {
+      return $('#gollum-editor .collapsed, #gollum-editor .expanded').length;
+    },
+    /**
+     *  EditorHas.formatSelector
+     *  True if the editor has a format selector (for switching between
+     *  language types), false otherwise.
+     *
+     *  @return boolean
+     */
+    formatSelector: function() {
+      return $('#gollum-editor-format-selector select').length;
+    },
+    /**
+     *  EditorHas.functionBar
+     *  True if the Function Bar markup exists.
+     *
+     *  @return boolean
+     */
+    functionBar: function() {
+      return ( ActiveOptions.HasFunctionBar &&
+               $('#gollum-editor-function-bar').length );
+    },
+    /**
+     *  EditorHas.ff4Environment
+     *  True if in a Firefox 4.0 Beta environment.
+     *
+     *  @return boolean
+     */
+    ff4Environment: function() {
+      var ua = new RegExp(/Firefox\/4.0b/);
+      return ( ua.test( navigator.userAgent ) );
+    },
+    /**
+     *  EditorHas.editSummaryMarkup
+     *  True if the editor has a summary field (Gollum's commit message),
+     *  false otherwise.
+     *
+     *  @return boolean
+     */
+    editSummaryMarkup: function() {
+      return ( $('input#gollum-editor-message-field').length > 0 );
+    },
+    /**
+     *  EditorHas.help
+     *  True if the editor contains the inline help sector, false otherwise.
+     *
+     *  @return boolean
+     */
+    help: function() {
+      return ( $('#gollum-editor #gollum-editor-help').length &&
+               $('#gollum-editor #function-help').length );
+    },
+    /**
+     *  EditorHas.mathJax
+     *  True if the editor has MathJax enabled and running, false otherwise.
+     *
+     *  @return boolean
+     */
+    mathJax: function() {
+      return (typeof window.MathJax == 'object');
+    },
+    /**
+     *  EditorHas.previewButton
+     *  True if the editor has a preview button, false otherwise.
+     *
+     *  @return boolean
+     */
+    previewButton: function() {
+      return ( $('#gollum-editor #gollum-editor-preview').length );
+    },
+    /**
+     *  EditorHas.titleDisplayed
+     *  True if the editor is displaying a title field, false otherwise.
+     *
+     *  @return boolean
+     */
+    titleDisplayed: function() {
+      return ( ActiveOptions.NewFile );
+    }
+  };
+  /**
+   *  FunctionBar
+   *
+   *  Things the function bar does.
+   */
+   var FunctionBar = {
+      isActive: false,
+      /**
+       *  FunctionBar.activate
+       *  Activates the function bar, attaching all click events
+       *  and displaying the bar.
+       *
+       */
+      activate: function() {
+        debug('Activating function bar');
+        // check these out
+        $('#gollum-editor-function-bar a.function-button').each(function() {
+          if ( LanguageDefinition.getDefinitionFor( $(this).attr('id') ) ) {
+            $(this).click( FunctionBar.evtFunctionButtonClick );
+            $(this).removeClass('disabled');
+          }
+          else if ( $(this).attr('id') != 'function-help' ) {
+            $(this).addClass('disabled');
+          }
+        });
+        // show bar as active
+        $('#gollum-editor-function-bar').addClass( 'active' );
+        FunctionBar.isActive = true;
+      },
+      deactivate: function() {
+        $('#gollum-editor-function-bar a.function-button').unbind('click');
+        $('#gollum-editor-function-bar').removeClass( 'active' );
+        FunctionBar.isActive = false;
+      },
+      /**
+       *  FunctionBar.evtFunctionButtonClick
+       *  Event handler for the function buttons. Traps the click and
+       *  executes the proper language action.
+       *
+       *  @param jQuery.Event jQuery event object.
+       */
+      evtFunctionButtonClick: function(e) {
+        e.preventDefault();
+        var def = LanguageDefinition.getDefinitionFor( $(this).attr('id') );
+        if ( typeof def == 'object' ) {
+          FunctionBar.executeAction( def );
+        }
+      },
+      /**
+       *  FunctionBar.executeAction
+       *  Executes a language-specific defined action for a function button.
+       *
+       */
+      executeAction: function( definitionObject ) {
+        // get the selected text from the textarea
+        var txt = $('#gollum-editor-body').val();
+        // hmm, I'm not sure this will work in a textarea
+        var selPos = FunctionBar
+                      .getFieldSelectionPosition( $('#gollum-editor-body') );
+        var selText = FunctionBar.getFieldSelection( $('#gollum-editor-body') );
+        var repText = selText;
+        var reselect = true;
+        var cursor = null;
+        // execute a replacement function if one exists
+        if ( definitionObject.exec &&
+             typeof definitionObject.exec == 'function' ) {
+          definitionObject.exec( txt, selText, $('#gollum-editor-body') );
+          return;
+        }
+        // execute a search/replace if they exist
+        var searchExp = /([^\n]+)/gi;
+        if ( definitionObject.search &&
+             typeof definitionObject.search == 'object' ) {
+          debug('Replacing search Regex');
+          searchExp = null;
+          searchExp = new RegExp ( definitionObject.search );
+          debug( searchExp );
+        }
+        debug('repText is ' + '"' + repText + '"');
+        // replace text
+        if ( definitionObject.replace &&
+             typeof definitionObject.replace == 'string' ) {
+          debug('Running replacement - using ' + definitionObject.replace);
+          var rt = definitionObject.replace;
+          repText = repText.replace( searchExp, rt );
+          // remove backreferences
+          repText = repText.replace( /\$[\d]/g, '' );
+          if ( repText === '' ) {
+            debug('Search string is empty');
+            // find position of $1 - this is where we will place the cursor
+            cursor = rt.indexOf('$1');
+            // we have an empty string, so just remove backreferences
+            repText = rt.replace( /\$[\d]/g, '' );
+            // if the position of $1 doesn't exist, stick the cursor in
+            // the middle
+            if ( cursor == -1 ) {
+              cursor = Math.floor( rt.length / 2 );
+            }
+          }
+        }
+        // append if necessary
+        if ( definitionObject.append &&
+             typeof definitionObject.append == 'string' ) {
+          if ( repText == selText ) {
+            reselect = false;
+          }
+          repText += definitionObject.append;
+        }
+        if ( repText ) {
+          FunctionBar.replaceFieldSelection( $('#gollum-editor-body'),
+                                             repText, reselect, cursor );
+        }
+      },
+      /**
+       *  getFieldSelectionPosition
+       *  Retrieves the selection range for the textarea.
+       *
+       *  @return object the .start and .end offsets in the string
+       */
+      getFieldSelectionPosition: function( $field ) {
+        if ($field.length) {
+          var start = 0, end = 0;
+          var el = $field.get(0);
+          if (typeof el.selectionStart == "number" &&
+              typeof el.selectionEnd == "number") {
+            start = el.selectionStart;
+            end = el.selectionEnd;
+          } else {
+            var range = document.selection.createRange();
+            var stored_range = range.duplicate();
+            stored_range.moveToElementText( el );
+            stored_range.setEndPoint( 'EndToEnd', range );
+            start = stored_range.text.length - range.text.length;
+            end = start + range.text.length;
+            // so, uh, we're close, but we need to search for line breaks and
+            // adjust the start/end points accordingly since IE counts them as
+            // 2 characters in TextRange.
+            var s = start;
+            var lb = 0;
+            var i;
+            debug('IE: start position is currently ' + s);
+            for ( i=0; i < s; i++ ) {
+              if ( el.value.charAt(i).match(/\r/) ) {
+                ++lb;
+              }
+            }
+            if ( lb ) {
+              debug('IE start: compensating for ' + lb + ' line breaks');
+              start = start - lb;
+              lb = 0;
+            }
+            var e = end;
+            for ( i=0; i < e; i++ ) {
+              if ( el.value.charAt(i).match(/\r/) ) {
+                ++lb;
+              }
+            }
+            if ( lb ) {
+              debug('IE end: compensating for ' + lb + ' line breaks');
+              end = end - lb;
+            }
+          }
+          return {
+              start: start,
+              end: end
+          };
+        } // end if ($field.length)
+      },
+      /**
+       *  getFieldSelection
+       *  Returns the currently selected substring of the textarea.
+       *
+       *  @param  jQuery  A jQuery object for the textarea.
+       *  @return string  Selected string.
+       */
+      getFieldSelection: function( $field ) {
+        var selStr = '';
+        var selPos;
+        if ( $field.length ) {
+          selPos = FunctionBar.getFieldSelectionPosition( $field );
+          selStr = $field.val().substring( selPos.start, selPos.end );
+          debug('Selected: ' + selStr + ' (' + selPos.start + ', ' +
+                selPos.end + ')');
+          return selStr;
+        }
+        return false;
+      },
+      isShown: function() {
+        return ($('#gollum-editor-function-bar').is(':visible'));
+      },
+      refresh: function() {
+        if ( EditorHas.functionBar() ) {
+          debug('Refreshing function bar');
+          if ( LanguageDefinition.isValid() ) {
+            $('#gollum-editor-function-bar a.function-button').unbind('click');
+            FunctionBar.activate();
+            if ( Help ) {
+              Help.setActiveHelp( LanguageDefinition.getActiveLanguage() );
+            }
+          } else {
+            debug('Language definition is invalid.');
+            if ( FunctionBar.isShown() ) {
+              // deactivate the function bar; it's not gonna work now
+              FunctionBar.deactivate();
+            }
+            if ( Help.isShown() ) {
+              Help.hide();
+            }
+          }
+        }
+      },
+      /**
+       *  replaceFieldSelection
+       *  Replaces the currently selected substring of the textarea with
+       *  a new string.
+       *
+       *  @param  jQuery  A jQuery object for the textarea.
+       *  @param  string  The string to replace the current selection with.
+       *  @param  boolean Reselect the new text range.
+       */
+      replaceFieldSelection: function( $field, replaceText, reselect, cursorOffset ) {
+        var selPos = FunctionBar.getFieldSelectionPosition( $field );
+        var fullStr = $field.val();
+        var selectNew = true;
+        if ( reselect === false) {
+          selectNew = false;
+        }
+        var scrollTop = null;
+        if ( $field[0].scrollTop ) {
+          scrollTop = $field[0].scrollTop;
+        }
+        $field.val( fullStr.substring(0, selPos.start) + replaceText +
+                    fullStr.substring(selPos.end) );
+        $field[0].focus();
+        if ( selectNew ) {
+          if ( $field[0].setSelectionRange ) {
+            if ( cursorOffset ) {
+              $field[0].setSelectionRange(
+                                            selPos.start + cursorOffset,
+                                            selPos.start + cursorOffset
+               );
+            } else {
+              $field[0].setSelectionRange( selPos.start,
+                                           selPos.start + replaceText.length );
+            }
+          } else if ( $field[0].createTextRange ) {
+            var range = $field[0].createTextRange();
+            range.collapse( true );
+            if ( cursorOffset ) {
+              range.moveEnd( selPos.start + cursorOffset );
+              range.moveStart( selPos.start + cursorOffset );
+            } else {
+              range.moveEnd( 'character', selPos.start + replaceText.length );
+              range.moveStart( 'character', selPos.start );
+            }
+            range.select();
+          }
+        }
+        if ( scrollTop ) {
+          // this jumps sometimes in FF
+          $field[0].scrollTop = scrollTop;
+        }
+      }
+   };
+   /**
+    *  FormatSelector
+    *
+    *  Functions relating to the format selector (if it exists)
+    */
+   var FormatSelector = {
+     $_SELECTOR: null,
+     /**
+      *  FormatSelector.evtChangeFormat
+      *  Event handler for when a format has been changed by the format
+      *  selector. Will automatically load a new language definition
+      *  via JS if necessary.
+      *
+      *  @return void
+      */
+     evtChangeFormat: function( e ) {
+       var newMarkup = $(this).val();
+       LanguageDefinition.setActiveLanguage( newMarkup );
+     },
+     /**
+      *  FormatSelector.init
+      *  Initializes the format selector.
+      *
+      *  @return void
+      */
+     init: function( $sel ) {
+       debug('Initializing format selector');
+       // unbind events if init is being called twice for some reason
+       if ( FormatSelector.$_SELECTOR &&
+            typeof FormatSelector.$_SELECTOR == 'object' ) {
+         FormatSelector.$_SELECTOR.unbind( 'change' );
+       }
+       FormatSelector.$_SELECTOR = $sel;
+       // set format selector to the current language
+       FormatSelector.updateSelected();
+       FormatSelector.$_SELECTOR.change( FormatSelector.evtChangeFormat );
+     },
+     /**
+      * FormatSelector.update
+      */
+    updateSelected: function() {
+       var currentLang = LanguageDefinition.getActiveLanguage();
+       FormatSelector.$_SELECTOR.val( currentLang );
+    }
+   };
+   /**
+    *  Help
+    *
+    *  Functions that manage the display and loading of inline help files.
+    */
+  var Help = {
+    _ACTIVE_HELP: '',
+   _LOADED_HELP_LANGS: [],
+   _HELP: {},
+   /**
+    *  Help.define
+    *
+    *  Defines a new help context and enables the help function if it
+    *  exists in the Gollum Function Bar.
+    *
+    *  @param string name   The name you're giving to this help context.
+    *                       Generally, this should match the language name.
+    *  @param object definitionObject The definition object being loaded from a
+    *                                 language / help definition file.
+    *  @return void
+    */
+   define: function( name, definitionObject ) {
+     if ( Help.isValidHelpFormat( definitionObject ) ) {
+       debug('help is a valid format');
+       Help._ACTIVE_HELP_LANG = name;
+       Help._LOADED_HELP_LANGS.push( name );
+       Help._HELP[name] = definitionObject;
+       if ( $("#function-help").length ) {
+         if ( $('#function-help').hasClass('disabled') ) {
+           $('#function-help').removeClass('disabled');
+         }
+         $('#function-help').unbind('click');
+         $('#function-help').click( Help.evtHelpButtonClick );
+         // generate help menus
+         Help.generateHelpMenuFor( name );
+       }
+     } else {
+       if ( $('#function-help').length ) {
+         $('#function-help').addClass('disabled');
+       }
+     }
+   },
+   /**
+    *  Help.generateHelpMenuFor
+    *  Generates the markup for the main help menu given a context name.
+    *
+    *  @param string  name  The context name.
+    *  @return void
+    */
+   generateHelpMenuFor: function( name ) {
+     if ( !Help._HELP[name] ) {
+       debug('Help is not defined for ' + name.toString());
+       return false;
+     }
+     var helpData = Help._HELP[name];
+     if ( EditorHas.mathJax() && Help.isLoadedFor('mathjax') ) {
+       debug('Adding MathJax support to help');
+       // TODO
+     }
+     // clear this shiz out
+     $('#gollum-editor-help-parent').html('');
+     $('#gollum-editor-help-list').html('');
+     $('#gollum-editor-help-content').html('');
+     // go go inefficient algorithm
+     for ( var i=0; i < helpData.length; i++ ) {
+       if ( typeof helpData[i] != 'object' ) {
+         break;
+       }
+       var $newLi = $('<li><a href="#" rel="' + i + '">' +
+                      helpData[i].menuName + '</a></li>');
+       $('#gollum-editor-help-parent').append( $newLi );
+       if ( i === 0 ) {
+         // select on first run
+         $newLi.children('a').addClass('selected');
+       }
+       $newLi.children('a').click( Help.evtParentMenuClick );
+     }
+     // generate parent submenu on first run
+     Help.generateSubMenu( helpData[0], 0 );
+     $($('#gollum-editor-help-list li a').get(0)).click();
+   },
+   /**
+    *  Help.generateSubMenu
+    *  Generates the markup for the inline help sub-menu given the data
+    *  object for the submenu and the array index to start at.
+    *
+    *  @param object subData The data for the sub-menu.
+    *  @param integer index  The index clicked on (parent menu index).
+    *  @return void
+    */
+   generateSubMenu: function( subData, index ) {
+     $('#gollum-editor-help-list').html('');
+     $('#gollum-editor-help-content').html('');
+     for ( var i=0; i < subData.content.length; i++ ) {
+       if ( typeof subData.content[i] != 'object' ) {
+         break;
+       }
+       var $subLi = $('<li><a href="#" rel="' + index + ':' + i + '">' +
+                      subData.content[i].menuName + '</a></li>');
+       $('#gollum-editor-help-list').append( $subLi );
+       $subLi.children('a').click( Help.evtSubMenuClick );
+     }
+   },
+   hide: function() {
+     if ( $.browser.msie ) {
+       $('#gollum-editor-help').css('display', 'none');
+     } else {
+       $('#gollum-editor-help').animate({
+                                          opacity: 0
+                                         }, 200,
+                                        function() {
+                                          $('#gollum-editor-help')
+                                            .animate({ height: 'hide' }, 200);
+                                        });
+     }
+   },
+   show: function() {
+     if ( $.browser.msie ) {
+       // bypass effects for internet explorer, since it does weird crap
+       // to text antialiasing with opacity animations
+       $('#gollum-editor-help').css('display', 'block');
+     } else {
+       $('#gollum-editor-help').animate({
+                                    height: 'show'
+                                   }, 200,
+                                  function() {
+                                    $('#gollum-editor-help')
+                                      .animate({ opacity: 1 }, 300);
+                                  });
+     }
+   },
+   /**
+    *  Help.showHelpFor
+    *  Displays the actual help content given the two menu indexes, which are
+    *  rendered in the rel="" attributes of the help menus
+    *
+    *  @param integer index1  parent index
+    *  @param integer index2  submenu index
+    *  @return void
+    */
+   showHelpFor: function( index1, index2 ) {
+     var html =
+       Help._HELP[Help._ACTIVE_HELP_LANG][index1].content[index2].data;
+     $('#gollum-editor-help-content').html(html);
+   },
+   /**
+    *  Help.isLoadedFor
+    *  Returns true if help is loaded for a specific markup language,
+    *  false otherwise.
+    *
+    *  @param string name   The name of the markup language.
+    *  @return boolean
+    */
+   isLoadedFor: function( name ) {
+     for ( var i=0; i < Help._LOADED_HELP_LANGS.length; i++ ) {
+       if ( name == Help._LOADED_HELP_LANGS[i] ) {
+         return true;
+       }
+     }
+     return false;
+   },
+   isShown: function() {
+     return ( $('#gollum-editor-help').is(':visible') );
+   },
+   /**
+    *  Help.isValidHelpFormat
+    *  Does a quick check to make sure that the help definition isn't in a
+    *  completely messed-up format.
+    *
+    *  @param object (Array) helpArr  The help definition array.
+    *  @return boolean
+    */
+   isValidHelpFormat: function( helpArr ) {
+     return ( typeof helpArr == 'object' &&
+              helpArr.length &&
+              typeof helpArr[0].menuName == 'string' &&
+              typeof helpArr[0].content == 'object' &&
+              helpArr[0].content.length );
+   },
+   /**
+    *  Help.setActiveHelp
+    *  Sets the active help definition to the one defined in the argument,
+    *  re-rendering the help menu to match the new definition.
+    *
+    *  @param string  name  The name of the help definition.
+    *  @return void
+    */
+   setActiveHelp: function( name ) {
+     if ( !Help.isLoadedFor( name ) ) {
+       if ( $('#function-help').length ) {
+         $('#function-help').addClass('disabled');
+       }
+       if ( Help.isShown() ) {
+         Help.hide();
+       }
+     } else {
+        Help._ACTIVE_HELP_LANG = name;
+        if ( $("#function-help").length ) {
+          if ( $('#function-help').hasClass('disabled') ) {
+            $('#function-help').removeClass('disabled');
+          }
+          $('#function-help').unbind('click');
+          $('#function-help').click( Help.evtHelpButtonClick );
+          Help.generateHelpMenuFor( name );
+        }
+     }
+   },
+   /**
+    *  Help.evtHelpButtonClick
+    *  Event handler for clicking the help button in the function bar.
+    *
+    *  @param jQuery.Event e  The jQuery event object.
+    *  @return void
+    */
+   evtHelpButtonClick: function( e ) {
+     e.preventDefault();
+     if ( Help.isShown() ) { Help.hide(); }
+     else { Help.show(); }
+   },
+   /**
+    *  Help.evtParentMenuClick
+    *  Event handler for clicking on an item in the parent menu. Automatically
+    *  renders the submenu for the parent menu as well as the first result for
+    *  the actual plain text.
+    *
+    *  @param jQuery.Event e  The jQuery event object.
+    *  @return void
+    */
+   evtParentMenuClick: function( e ) {
+     e.preventDefault();
+     // short circuit if we've selected this already
+     if ( $(this).hasClass('selected') ) { return; }
+     // populate from help data for this
+     var helpIndex = $(this).attr('rel');
+     var subData = Help._HELP[Help._ACTIVE_HELP_LANG][helpIndex];
+     $('#gollum-editor-help-parent li a').removeClass('selected');
+     $(this).addClass('selected');
+     Help.generateSubMenu( subData, helpIndex );
+     $($('#gollum-editor-help-list li a').get(0)).click();
+   },
+   /**
+    *  Help.evtSubMenuClick
+    *  Event handler for clicking an item in a help submenu. Renders the
+    *  appropriate text for the submenu link.
+    *
+    *  @param jQuery.Event e  The jQuery event object.
+    *  @return void
+    */
+   evtSubMenuClick: function( e ) {
+     e.preventDefault();
+     if ( $(this).hasClass('selected') ) { return; }
+     // split index rel data
+     var rawIndex = $(this).attr('rel').split(':');
+     $('#gollum-editor-help-list li a').removeClass('selected');
+     $(this).addClass('selected');
+     Help.showHelpFor( rawIndex[0], rawIndex[1] );
+   }
+ };
+   // Publicly-accessible function to Help.define
+   $.GollumEditor.defineHelp = Help.define;
+   // Dialog exists as its own thing now
+   $.GollumEditor.Dialog = $.GollumDialog;
+   $.GollumEditor.replaceSelection = function( repText ) {
+     FunctionBar.replaceFieldSelection( $('#gollum-editor-body'), repText );
+   };
+   // Placeholder exists as its own thing now
+   $.GollumEditor.Placeholder = $.GollumPlaceholder;
+})(jQuery);