esp-ckeditor 0.1.0

data/app/assets/javascripts/esp-ckeditor/_source/core/htmlparser/text.js

@@ -0,0 +1,53 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  /**
+   * A lightweight representation of HTML text.
+   * @constructor
+   * @example
+   */
+   CKEDITOR.htmlParser.text = function( value )
+  {
+    /**
+     * The text value.
+     * @type String
+     * @example
+     */
+    this.value = value;
+
+    /** @private */
+    this._ =
+    {
+      isBlockLike : false
+    };
+  };
+
+  CKEDITOR.htmlParser.text.prototype =
+  {
+    /**
+     * The node type. This is a constant value set to {@link CKEDITOR.NODE_TEXT}.
+     * @type Number
+     * @example
+     */
+    type : CKEDITOR.NODE_TEXT,
+
+    /**
+     * Writes the HTML representation of this text to a CKEDITOR.htmlWriter.
+     * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+     * @example
+     */
+    writeHtml : function( writer, filter )
+    {
+      var text = this.value;
+
+      if ( filter && !( text = filter.onText( text, this ) ) )
+        return;
+
+      writer.text( text );
+    }
+  };
+})();

data/app/assets/javascripts/esp-ckeditor/_source/core/htmlparser.js

@@ -0,0 +1,224 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * Creates a {@link CKEDITOR.htmlParser} class instance.
+ * @class Provides an "event like" system to parse strings of HTML data.
+ * @example
+ * var parser = new CKEDITOR.htmlParser();
+ * parser.onTagOpen = function( tagName, attributes, selfClosing )
+ *     {
+ *         alert( tagName );
+ *     };
+ * parser.parse( '<p>Some <b>text</b>.</p>' );
+ */
+CKEDITOR.htmlParser = function()
+{
+  this._ =
+  {
+    htmlPartsRegex : new RegExp( '<(?:(?:\\/([^>]+)>)|(?:!--([\\S|\\s]*?)-->)|(?:([^\\s>]+)\\s*((?:(?:"[^"]*")|(?:\'[^\']*\')|[^"\'>])*)\\/?>))', 'g' )
+  };
+};
+
+(function()
+{
+  var attribsRegex  = /([\w\-:.]+)(?:(?:\s*=\s*(?:(?:"([^"]*)")|(?:'([^']*)')|([^\s>]+)))|(?=\s|$))/g,
+    emptyAttribs  = {checked:1,compact:1,declare:1,defer:1,disabled:1,ismap:1,multiple:1,nohref:1,noresize:1,noshade:1,nowrap:1,readonly:1,selected:1};
+
+  CKEDITOR.htmlParser.prototype =
+  {
+    /**
+     * Function to be fired when a tag opener is found. This function
+     * should be overriden when using this class.
+     * @param {String} tagName The tag name. The name is guarantted to be
+     *    lowercased.
+     * @param {Object} attributes An object containing all tag attributes. Each
+     *    property in this object represent and attribute name and its
+     *    value is the attribute value.
+     * @param {Boolean} selfClosing true if the tag closes itself, false if the
+     *     tag doesn't.
+     * @example
+     * var parser = new CKEDITOR.htmlParser();
+     * parser.onTagOpen = function( tagName, attributes, selfClosing )
+     *     {
+     *         alert( tagName );  // e.g. "b"
+     *     });
+     * parser.parse( "&lt;!-- Example --&gt;&lt;b&gt;Hello&lt;/b&gt;" );
+     */
+    onTagOpen  : function() {},
+
+    /**
+     * Function to be fired when a tag closer is found. This function
+     * should be overriden when using this class.
+     * @param {String} tagName The tag name. The name is guarantted to be
+     *    lowercased.
+     * @example
+     * var parser = new CKEDITOR.htmlParser();
+     * parser.onTagClose = function( tagName )
+     *     {
+     *         alert( tagName );  // e.g. "b"
+     *     });
+     * parser.parse( "&lt;!-- Example --&gt;&lt;b&gt;Hello&lt;/b&gt;" );
+     */
+    onTagClose  : function() {},
+
+    /**
+     * Function to be fired when text is found. This function
+     * should be overriden when using this class.
+     * @param {String} text The text found.
+     * @example
+     * var parser = new CKEDITOR.htmlParser();
+     * parser.onText = function( text )
+     *     {
+     *         alert( text );  // e.g. "Hello"
+     *     });
+     * parser.parse( "&lt;!-- Example --&gt;&lt;b&gt;Hello&lt;/b&gt;" );
+     */
+    onText    : function() {},
+
+    /**
+     * Function to be fired when CDATA section is found. This function
+     * should be overriden when using this class.
+     * @param {String} cdata The CDATA been found.
+     * @example
+     * var parser = new CKEDITOR.htmlParser();
+     * parser.onCDATA = function( cdata )
+     *     {
+     *         alert( cdata );  // e.g. "var hello;"
+     *     });
+     * parser.parse( "&lt;script&gt;var hello;&lt;/script&gt;" );
+     */
+    onCDATA    : function() {},
+
+    /**
+     * Function to be fired when a commend is found. This function
+     * should be overriden when using this class.
+     * @param {String} comment The comment text.
+     * @example
+     * var parser = new CKEDITOR.htmlParser();
+     * parser.onComment = function( comment )
+     *     {
+     *         alert( comment );  // e.g. " Example "
+     *     });
+     * parser.parse( "&lt;!-- Example --&gt;&lt;b&gt;Hello&lt;/b&gt;" );
+     */
+    onComment  : function() {},
+
+    /**
+     * Parses text, looking for HTML tokens, like tag openers or closers,
+     * or comments. This function fires the onTagOpen, onTagClose, onText
+     * and onComment function during its execution.
+     * @param {String} html The HTML to be parsed.
+     * @example
+     * var parser = new CKEDITOR.htmlParser();
+     * // The onTagOpen, onTagClose, onText and onComment should be overriden
+     * // at this point.
+     * parser.parse( "&lt;!-- Example --&gt;&lt;b&gt;Hello&lt;/b&gt;" );
+     */
+    parse : function( html )
+    {
+      var parts,
+        tagName,
+        nextIndex = 0,
+        cdata;  // The collected data inside a CDATA section.
+
+      while ( ( parts = this._.htmlPartsRegex.exec( html ) ) )
+      {
+        var tagIndex = parts.index;
+        if ( tagIndex > nextIndex )
+        {
+          var text = html.substring( nextIndex, tagIndex );
+
+          if ( cdata )
+            cdata.push( text );
+          else
+            this.onText( text );
+        }
+
+        nextIndex = this._.htmlPartsRegex.lastIndex;
+
+        /*
+         "parts" is an array with the following items:
+          0 : The entire match for opening/closing tags and comments.
+          1 : Group filled with the tag name for closing tags.
+          2 : Group filled with the comment text.
+          3 : Group filled with the tag name for opening tags.
+          4 : Group filled with the attributes part of opening tags.
+         */
+
+        // Closing tag
+        if ( ( tagName = parts[ 1 ] ) )
+        {
+          tagName = tagName.toLowerCase();
+
+          if ( cdata && CKEDITOR.dtd.$cdata[ tagName ] )
+          {
+            // Send the CDATA data.
+            this.onCDATA( cdata.join('') );
+            cdata = null;
+          }
+
+          if ( !cdata )
+          {
+            this.onTagClose( tagName );
+            continue;
+          }
+        }
+
+        // If CDATA is enabled, just save the raw match.
+        if ( cdata )
+        {
+          cdata.push( parts[ 0 ] );
+          continue;
+        }
+
+        // Opening tag
+        if ( ( tagName = parts[ 3 ] ) )
+        {
+          tagName = tagName.toLowerCase();
+
+          // There are some tag names that can break things, so let's
+          // simply ignore them when parsing. (#5224)
+          if ( /="/.test( tagName ) )
+            continue;
+
+          var attribs = {},
+            attribMatch,
+            attribsPart = parts[ 4 ],
+            selfClosing = !!( attribsPart && attribsPart.charAt( attribsPart.length - 1 ) == '/' );
+
+          if ( attribsPart )
+          {
+            while ( ( attribMatch = attribsRegex.exec( attribsPart ) ) )
+            {
+              var attName = attribMatch[1].toLowerCase(),
+                attValue = attribMatch[2] || attribMatch[3] || attribMatch[4] || '';
+
+              if ( !attValue && emptyAttribs[ attName ] )
+                attribs[ attName ] = attName;
+              else
+                attribs[ attName ] = attValue;
+            }
+          }
+
+          this.onTagOpen( tagName, attribs, selfClosing );
+
+          // Open CDATA mode when finding the appropriate tags.
+          if ( !cdata && CKEDITOR.dtd.$cdata[ tagName ] )
+            cdata = [];
+
+          continue;
+        }
+
+        // Comment
+        if ( ( tagName = parts[ 2 ] ) )
+          this.onComment( tagName );
+      }
+
+      if ( html.length > nextIndex )
+        this.onText( html.substring( nextIndex, html.length ) );
+    }
+  };
+})();

data/app/assets/javascripts/esp-ckeditor/_source/core/lang.js

@@ -0,0 +1,157 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  var loadedLangs = {};
+
+  /**
+   * @namespace Holds language related functions.
+   */
+  CKEDITOR.lang =
+  {
+    /**
+     * The list of languages available in the editor core.
+     * @type Object
+     * @example
+     * alert( CKEDITOR.lang.en );  // "true"
+     */
+    languages :
+    {
+      'af'  : 1,
+      'ar'  : 1,
+      'bg'  : 1,
+      'bn'  : 1,
+      'bs'  : 1,
+      'ca'  : 1,
+      'cs'  : 1,
+      'cy'  : 1,
+      'da'  : 1,
+      'de'  : 1,
+      'el'  : 1,
+      'en-au'  : 1,
+      'en-ca'  : 1,
+      'en-gb'  : 1,
+      'en'  : 1,
+      'eo'  : 1,
+      'es'  : 1,
+      'et'  : 1,
+      'eu'  : 1,
+      'fa'  : 1,
+      'fi'  : 1,
+      'fo'  : 1,
+      'fr-ca'  : 1,
+      'fr'  : 1,
+      'gl'  : 1,
+      'gu'  : 1,
+      'he'  : 1,
+      'hi'  : 1,
+      'hr'  : 1,
+      'hu'  : 1,
+      'is'  : 1,
+      'it'  : 1,
+      'ja'  : 1,
+      'ka'  : 1,
+      'km'  : 1,
+      'ko'  : 1,
+      'lt'  : 1,
+      'lv'  : 1,
+      'mn'  : 1,
+      'ms'  : 1,
+      'nb'  : 1,
+      'nl'  : 1,
+      'no'  : 1,
+      'pl'  : 1,
+      'pt-br'  : 1,
+      'pt'  : 1,
+      'ro'  : 1,
+      'ru'  : 1,
+      'sk'  : 1,
+      'sl'  : 1,
+      'sr-latn'  : 1,
+      'sr'  : 1,
+      'sv'  : 1,
+      'th'  : 1,
+      'tr'  : 1,
+      'uk'  : 1,
+      'vi'  : 1,
+      'zh-cn'  : 1,
+      'zh'  : 1
+    },
+
+    /**
+     * Loads a specific language file, or auto detect it. A callback is
+     * then called when the file gets loaded.
+     * @param {String} languageCode The code of the language file to be
+     *    loaded. If null or empty, autodetection will be performed. The
+     *    same happens if the language is not supported.
+     * @param {String} defaultLanguage The language to be used if
+     *    languageCode is not supported or if the autodetection fails.
+     * @param {Function} callback A function to be called once the
+     *    language file is loaded. Two parameters are passed to this
+     *    function: the language code and the loaded language entries.
+     * @example
+     */
+    load : function( languageCode, defaultLanguage, callback )
+    {
+      // If no languageCode - fallback to browser or default.
+      // If languageCode - fallback to no-localized version or default.
+      if ( !languageCode || !CKEDITOR.lang.languages[ languageCode ] )
+        languageCode = this.detect( defaultLanguage, languageCode );
+
+      if ( !this[ languageCode ] )
+      {
+        CKEDITOR.scriptLoader.load( CKEDITOR.getUrl(
+          '_source/' +  // @Packager.RemoveLine
+          'lang/' + languageCode + '.js' ),
+          function()
+            {
+              callback( languageCode, this[ languageCode ] );
+            }
+            , this );
+      }
+      else
+        callback( languageCode, this[ languageCode ] );
+    },
+
+    /**
+     * Returns the language that best fit the user language. For example,
+     * suppose that the user language is "pt-br". If this language is
+     * supported by the editor, it is returned. Otherwise, if only "pt" is
+     * supported, it is returned instead. If none of the previous are
+     * supported, a default language is then returned.
+     * @param {String} defaultLanguage The default language to be returned
+     *    if the user language is not supported.
+     * @param {String} [probeLanguage] A language code to try to use,
+     *    instead of the browser based autodetection.
+     * @returns {String} The detected language code.
+     * @example
+     * alert( CKEDITOR.lang.detect( 'en' ) );  // e.g., in a German browser: "de"
+     */
+    detect : function( defaultLanguage, probeLanguage )
+    {
+      var languages = this.languages;
+      probeLanguage = probeLanguage || navigator.userLanguage || navigator.language || defaultLanguage;
+
+      var parts = probeLanguage
+          .toLowerCase()
+          .match( /([a-z]+)(?:-([a-z]+))?/ ),
+        lang = parts[1],
+        locale = parts[2];
+
+      if ( languages[ lang + '-' + locale ] )
+        lang = lang + '-' + locale;
+      else if ( !languages[ lang ] )
+        lang = null;
+
+      CKEDITOR.lang.detect = lang ?
+        function() { return lang; } :
+        function( defaultLanguage ) { return defaultLanguage; };
+
+      return lang || defaultLanguage;
+    }
+  };
+
+})();

data/app/assets/javascripts/esp-ckeditor/_source/core/loader.js

@@ -0,0 +1,240 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.loader} objects, which is used to
+ *    load core scripts and their dependencies from _source.
+ */
+
+if ( typeof CKEDITOR == 'undefined' )
+  CKEDITOR = {};
+
+if ( !CKEDITOR.loader )
+{
+  /**
+   * Load core scripts and their dependencies from _source.
+   * @namespace
+   * @example
+   */
+  CKEDITOR.loader = (function()
+  {
+    // Table of script names and their dependencies.
+    var scripts =
+    {
+      'core/_bootstrap'    : [ 'core/config', 'core/ckeditor', 'core/plugins', 'core/scriptloader', 'core/tools', /* The following are entries that we want to force loading at the end to avoid dependence recursion */ 'core/dom/comment', 'core/dom/elementpath', 'core/dom/text', 'core/dom/rangelist' ],
+      'core/ckeditor'      : [ 'core/ckeditor_basic', 'core/dom', 'core/dtd', 'core/dom/document', 'core/dom/element', 'core/editor', 'core/event', 'core/htmlparser', 'core/htmlparser/element', 'core/htmlparser/fragment', 'core/htmlparser/filter', 'core/htmlparser/basicwriter', 'core/tools' ],
+      'core/ckeditor_base'  : [],
+      'core/ckeditor_basic'  : [ 'core/editor_basic', 'core/env', 'core/event' ],
+      'core/command'      : [],
+      'core/config'      : [ 'core/ckeditor_base' ],
+      'core/dom'        : [],
+      'core/dom/comment'    : [ 'core/dom/node' ],
+      'core/dom/document'    : [ 'core/dom', 'core/dom/domobject', 'core/dom/window' ],
+      'core/dom/documentfragment'  : [ 'core/dom/element' ],
+      'core/dom/element'    : [ 'core/dom', 'core/dom/document', 'core/dom/domobject', 'core/dom/node', 'core/dom/nodelist', 'core/tools' ],
+      'core/dom/elementpath'  : [ 'core/dom/element' ],
+      'core/dom/event'    : [],
+      'core/dom/node'      : [ 'core/dom/domobject', 'core/tools' ],
+      'core/dom/nodelist'    : [ 'core/dom/node' ],
+      'core/dom/domobject'  : [ 'core/dom/event' ],
+      'core/dom/range'    : [ 'core/dom/document', 'core/dom/documentfragment', 'core/dom/element', 'core/dom/walker' ],
+      'core/dom/rangelist'    : [ 'core/dom/range' ],
+      'core/dom/text'      : [ 'core/dom/node', 'core/dom/domobject' ],
+      'core/dom/walker'    : [ 'core/dom/node' ],
+      'core/dom/window'    : [ 'core/dom/domobject' ],
+      'core/dtd'        : [ 'core/tools' ],
+      'core/editor'      : [ 'core/command', 'core/config', 'core/editor_basic', 'core/focusmanager', 'core/lang', 'core/plugins', 'core/skins', 'core/themes', 'core/tools', 'core/ui' ],
+      'core/editor_basic'    : [ 'core/event' ],
+      'core/env'        : [],
+      'core/event'      : [],
+      'core/focusmanager'    : [],
+      'core/htmlparser'    : [],
+      'core/htmlparser/comment'  : [ 'core/htmlparser' ],
+      'core/htmlparser/element'  : [ 'core/htmlparser', 'core/htmlparser/fragment' ],
+      'core/htmlparser/fragment'  : [ 'core/htmlparser', 'core/htmlparser/comment', 'core/htmlparser/text', 'core/htmlparser/cdata' ],
+      'core/htmlparser/text'    : [ 'core/htmlparser' ],
+      'core/htmlparser/cdata'    : [ 'core/htmlparser' ],
+      'core/htmlparser/filter'  : [ 'core/htmlparser' ],
+      'core/htmlparser/basicwriter': [ 'core/htmlparser' ],
+      'core/lang'        : [],
+      'core/plugins'      : [ 'core/resourcemanager' ],
+      'core/resourcemanager'  : [ 'core/scriptloader', 'core/tools' ],
+      'core/scriptloader'    : [ 'core/dom/element', 'core/env' ],
+      'core/skins'      : [ 'core/scriptloader' ],
+      'core/themes'      : [ 'core/resourcemanager' ],
+      'core/tools'      : [ 'core/env' ],
+      'core/ui'        : []
+    };
+
+    var basePath = (function()
+    {
+      // This is a copy of CKEDITOR.basePath, but requires the script having
+      // "_source/core/loader.js".
+      if ( CKEDITOR && CKEDITOR.basePath )
+        return CKEDITOR.basePath;
+
+      // Find out the editor directory path, based on its <script> tag.
+      var path = '';
+      var scripts = document.getElementsByTagName( 'script' );
+
+      for ( var i = 0 ; i < scripts.length ; i++ )
+      {
+        var match = scripts[i].src.match( /(^|.*?[\\\/])(?:_source\/)?core\/loader.js(?:\?.*)?$/i );
+
+        if ( match )
+        {
+          path = match[1];
+          break;
+        }
+      }
+
+      // In IE (only) the script.src string is the raw valued entered in the
+      // HTML. Other browsers return the full resolved URL instead.
+      if ( path.indexOf('://') == -1 )
+      {
+        // Absolute path.
+        if ( path.indexOf( '/' ) === 0 )
+          path = location.href.match( /^.*?:\/\/[^\/]*/ )[0] + path;
+        // Relative path.
+        else
+          path = location.href.match( /^[^\?]*\// )[0] + path;
+      }
+
+      return path;
+    })();
+
+    var timestamp = 'B8DJ5M3';
+
+    var getUrl = function( resource )
+    {
+      if ( CKEDITOR && CKEDITOR.getUrl )
+        return CKEDITOR.getUrl( resource );
+
+      return basePath + resource +
+        ( resource.indexOf( '?' ) >= 0 ? '&' : '?' ) +
+        't=' + timestamp;
+    };
+
+    var pendingLoad = [];
+
+    /** @lends CKEDITOR.loader */
+    return {
+      /**
+       * The list of loaded scripts in their loading order.
+       * @type Array
+       * @example
+       * // Alert the loaded script names.
+       * alert( <b>CKEDITOR.loader.loadedScripts</b> );
+       */
+      loadedScripts : [],
+
+      loadPending : function()
+      {
+        var scriptName = pendingLoad.shift();
+
+        if ( !scriptName )
+          return;
+
+        var scriptSrc = getUrl( '_source/' + scriptName + '.js' );
+
+        var script = document.createElement( 'script' );
+        script.type = 'text/javascript';
+        script.src = scriptSrc;
+
+        function onScriptLoaded()
+        {
+          // Append this script to the list of loaded scripts.
+          CKEDITOR.loader.loadedScripts.push( scriptName );
+
+          // Load the next.
+          CKEDITOR.loader.loadPending();
+        }
+
+        // We must guarantee the execution order of the scripts, so we
+        // need to load them one by one. (#4145)
+        // The following if/else block has been taken from the scriptloader core code.
+        if ( typeof(script.onreadystatechange) !== "undefined" )
+        {
+          /** @ignore */
+          script.onreadystatechange = function()
+          {
+            if ( script.readyState == 'loaded' || script.readyState == 'complete' )
+            {
+              script.onreadystatechange = null;
+              onScriptLoaded();
+            }
+          };
+        }
+        else
+        {
+          /** @ignore */
+          script.onload = function()
+          {
+            // Some browsers, such as Safari, may call the onLoad function
+            // immediately. Which will break the loading sequence. (#3661)
+            setTimeout( function() { onScriptLoaded( scriptName ); }, 0 );
+          };
+        }
+
+        document.body.appendChild( script );
+      },
+
+      /**
+       * Loads a specific script, including its dependencies. This is not a
+       * synchronous loading, which means that the code to be loaded will
+       * not necessarily be available after this call.
+       * @example
+       * CKEDITOR.loader.load( 'core/dom/element' );
+       */
+      load : function( scriptName, defer )
+      {
+        // Check if the script has already been loaded.
+        if ( scriptName in this.loadedScripts )
+          return;
+
+        // Get the script dependencies list.
+        var dependencies = scripts[ scriptName ];
+        if ( !dependencies )
+          throw 'The script name"' + scriptName + '" is not defined.';
+
+        // Mark the script as loaded, even before really loading it, to
+        // avoid cross references recursion.
+        this.loadedScripts[ scriptName ] = true;
+
+        // Load all dependencies first.
+        for ( var i = 0 ; i < dependencies.length ; i++ )
+          this.load( dependencies[ i ], true );
+
+        var scriptSrc = getUrl( '_source/' + scriptName + '.js' );
+
+        // Append the <script> element to the DOM.
+        // If the page is fully loaded, we can't use document.write
+        // but if the script is run while the body is loading then it's safe to use it
+        // Unfortunately, Firefox <3.6 doesn't support document.readyState, so it won't get this improvement
+        if ( document.body && (!document.readyState || document.readyState == 'complete') )
+        {
+          pendingLoad.push( scriptName );
+
+          if ( !defer )
+            this.loadPending();
+        }
+        else
+        {
+          // Append this script to the list of loaded scripts.
+          this.loadedScripts.push( scriptName );
+
+          document.write( '<script src="' + scriptSrc + '" type="text/javascript"><\/script>' );
+        }
+      }
+    };
+  })();
+}
+
+// Check if any script has been defined for autoload.
+if ( CKEDITOR._autoLoad )
+{
+  CKEDITOR.loader.load( CKEDITOR._autoLoad );
+  delete CKEDITOR._autoLoad;
+}