Redmine

/*  Prototype JavaScript framework, version 1.7

 *  (c) 2005-2010 Sam Stephenson

 *

 *  Prototype is freely distributable under the terms of an MIT-style license.

 *  For details, see the Prototype web site: http://www.prototypejs.org/

 *

 *--------------------------------------------------------------------------*/

var Prototype = {

  Version: '1.7',

  Browser: (function(){

    var ua = navigator.userAgent;

    var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';

    return {

      IE:             !!window.attachEvent && !isOpera,

      Opera:          isOpera,

      WebKit:         ua.indexOf('AppleWebKit/') > -1,

      Gecko:          ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,

      MobileSafari:   /Apple.*Mobile/.test(ua)

    }

  })(),

  BrowserFeatures: {

    XPath: !!document.evaluate,

    SelectorsAPI: !!document.querySelector,

    ElementExtensions: (function() {

      var constructor = window.Element || window.HTMLElement;

      return !!(constructor && constructor.prototype);

    })(),

    SpecificElementExtensions: (function() {

      if (typeof window.HTMLDivElement !== 'undefined')

        return true;

      var div = document.createElement('div'),

          form = document.createElement('form'),

          isSupported = false;

      if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {

        isSupported = true;

      }

      div = form = null;

      return isSupported;

    })()

  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',

  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

  emptyFunction: function() { },

  K: function(x) { return x }

};

if (Prototype.Browser.MobileSafari)

  Prototype.BrowserFeatures.SpecificElementExtensions = false;

var Abstract = { };

var Try = {

  these: function() {

    var returnValue;

    for (var i = 0, length = arguments.length; i < length; i++) {

      var lambda = arguments[i];

      try {

        returnValue = lambda();

        break;

      } catch (e) { }

    }

    return returnValue;

  }

};

/* Based on Alex Arnell's inheritance implementation. */

var Class = (function() {

  var IS_DONTENUM_BUGGY = (function(){

    for (var p in { toString: 1 }) {

      if (p === 'toString') return false;

    }

    return true;

  })();

  function subclass() {};

  function create() {

    var parent = null, properties = $A(arguments);

    if (Object.isFunction(properties[0]))

      parent = properties.shift();

    function klass() {

      this.initialize.apply(this, arguments);

    }

    Object.extend(klass, Class.Methods);

    klass.superclass = parent;

    klass.subclasses = [];

    if (parent) {

      subclass.prototype = parent.prototype;

      klass.prototype = new subclass;

      parent.subclasses.push(klass);

    }

    for (var i = 0, length = properties.length; i < length; i++)

      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)

      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;

    return klass;

  }

  function addMethods(source) {

    var ancestor   = this.superclass && this.superclass.prototype,

        properties = Object.keys(source);

    if (IS_DONTENUM_BUGGY) {

      if (source.toString != Object.prototype.toString)

        properties.push("toString");

      if (source.valueOf != Object.prototype.valueOf)

        properties.push("valueOf");

    }

    for (var i = 0, length = properties.length; i < length; i++) {

      var property = properties[i], value = source[property];

      if (ancestor && Object.isFunction(value) &&

          value.argumentNames()[0] == "$super") {

        var method = value;

        value = (function(m) {

          return function() { return ancestor[m].apply(this, arguments); };

        })(property).wrap(method);

        value.valueOf = method.valueOf.bind(method);

        value.toString = method.toString.bind(method);

      }

      this.prototype[property] = value;

    }

    return this;

  }

  return {

    create: create,

    Methods: {

      addMethods: addMethods

    }

  };

})();

(function() {

  var _toString = Object.prototype.toString,

      NULL_TYPE = 'Null',

      UNDEFINED_TYPE = 'Undefined',

      BOOLEAN_TYPE = 'Boolean',

      NUMBER_TYPE = 'Number',

      STRING_TYPE = 'String',

      OBJECT_TYPE = 'Object',

      FUNCTION_CLASS = '[object Function]',

      BOOLEAN_CLASS = '[object Boolean]',

      NUMBER_CLASS = '[object Number]',

      STRING_CLASS = '[object String]',

      ARRAY_CLASS = '[object Array]',

      DATE_CLASS = '[object Date]',

      NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&

        typeof JSON.stringify === 'function' &&

        JSON.stringify(0) === '0' &&

        typeof JSON.stringify(Prototype.K) === 'undefined';

  function Type(o) {

    switch(o) {

      case null: return NULL_TYPE;

      case (void 0): return UNDEFINED_TYPE;

    }

    var type = typeof o;

    switch(type) {

      case 'boolean': return BOOLEAN_TYPE;

      case 'number':  return NUMBER_TYPE;

      case 'string':  return STRING_TYPE;

    }

    return OBJECT_TYPE;

  }

  function extend(destination, source) {

    for (var property in source)

      destination[property] = source[property];

    return destination;

  }

  function inspect(object) {

    try {

      if (isUndefined(object)) return 'undefined';

      if (object === null) return 'null';

      return object.inspect ? object.inspect() : String(object);

    } catch (e) {

      if (e instanceof RangeError) return '...';

      throw e;

    }

  }

  function toJSON(value) {

    return Str('', { '': value }, []);

  }

  function Str(key, holder, stack) {

    var value = holder[key],

        type = typeof value;

    if (Type(value) === OBJECT_TYPE && typeof value.toJSON === 'function') {

      value = value.toJSON(key);

    }

    var _class = _toString.call(value);

    switch (_class) {

      case NUMBER_CLASS:

      case BOOLEAN_CLASS:

      case STRING_CLASS:

        value = value.valueOf();

    }

    switch (value) {

      case null: return 'null';

      case true: return 'true';

      case false: return 'false';

    }

    type = typeof value;

    switch (type) {

      case 'string':

        return value.inspect(true);

      case 'number':

        return isFinite(value) ? String(value) : 'null';

      case 'object':

        for (var i = 0, length = stack.length; i < length; i++) {

          if (stack[i] === value) { throw new TypeError(); }

        }

        stack.push(value);

        var partial = [];

        if (_class === ARRAY_CLASS) {

          for (var i = 0, length = value.length; i < length; i++) {

            var str = Str(i, value, stack);

            partial.push(typeof str === 'undefined' ? 'null' : str);

          }

          partial = '[' + partial.join(',') + ']';

        } else {

          var keys = Object.keys(value);

          for (var i = 0, length = keys.length; i < length; i++) {

            var key = keys[i], str = Str(key, value, stack);

            if (typeof str !== "undefined") {

               partial.push(key.inspect(true)+ ':' + str);

             }

          }

          partial = '{' + partial.join(',') + '}';

        }

        stack.pop();

        return partial;

    }

  }

  function stringify(object) {

    return JSON.stringify(object);

  }

  function toQueryString(object) {

    return $H(object).toQueryString();

  }

  function toHTML(object) {

    return object && object.toHTML ? object.toHTML() : String.interpret(object);

  }

  function keys(object) {

    if (Type(object) !== OBJECT_TYPE) { throw new TypeError(); }

    var results = [];

    for (var property in object) {

      if (object.hasOwnProperty(property)) {

        results.push(property);

      }

    }

    return results;

  }

  function values(object) {

    var results = [];

    for (var property in object)

      results.push(object[property]);

    return results;

  }

  function clone(object) {

    return extend({ }, object);

  }

  function isElement(object) {

    return !!(object && object.nodeType == 1);

  }

  function isArray(object) {

    return _toString.call(object) === ARRAY_CLASS;

  }

  var hasNativeIsArray = (typeof Array.isArray == 'function')

    && Array.isArray([]) && !Array.isArray({});

  if (hasNativeIsArray) {

    isArray = Array.isArray;

  }

  function isHash(object) {

    return object instanceof Hash;

  }

  function isFunction(object) {

    return _toString.call(object) === FUNCTION_CLASS;

  }

  function isString(object) {

    return _toString.call(object) === STRING_CLASS;

  }

  function isNumber(object) {

    return _toString.call(object) === NUMBER_CLASS;

  }

  function isDate(object) {

    return _toString.call(object) === DATE_CLASS;

  }

  function isUndefined(object) {

    return typeof object === "undefined";

  }

  extend(Object, {

    extend:        extend,

    inspect:       inspect,

    toJSON:        NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON,

    toQueryString: toQueryString,

    toHTML:        toHTML,

    keys:          Object.keys || keys,

    values:        values,

    clone:         clone,

    isElement:     isElement,

    isArray:       isArray,

    isHash:        isHash,

    isFunction:    isFunction,

    isString:      isString,

    isNumber:      isNumber,

    isDate:        isDate,

    isUndefined:   isUndefined

  });

})();

Object.extend(Function.prototype, (function() {

  var slice = Array.prototype.slice;

  function update(array, args) {

    var arrayLength = array.length, length = args.length;

    while (length--) array[arrayLength + length] = args[length];

    return array;

  }

  function merge(array, args) {

    array = slice.call(array, 0);

    return update(array, args);

  }

  function argumentNames() {

    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]

      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')

      .replace(/\s+/g, '').split(',');

    return names.length == 1 && !names[0] ? [] : names;

  }

  function bind(context) {

    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;

    var __method = this, args = slice.call(arguments, 1);

    return function() {

      var a = merge(args, arguments);

      return __method.apply(context, a);

    }

  }

  function bindAsEventListener(context) {

    var __method = this, args = slice.call(arguments, 1);

    return function(event) {

      var a = update([event || window.event], args);

      return __method.apply(context, a);

    }

  }

  function curry() {

    if (!arguments.length) return this;

    var __method = this, args = slice.call(arguments, 0);

    return function() {

      var a = merge(args, arguments);

      return __method.apply(this, a);

    }

  }

  function delay(timeout) {

    var __method = this, args = slice.call(arguments, 1);

    timeout = timeout * 1000;

    return window.setTimeout(function() {

      return __method.apply(__method, args);

    }, timeout);

  }

  function defer() {

    var args = update([0.01], arguments);

    return this.delay.apply(this, args);

  }

  function wrap(wrapper) {

    var __method = this;

    return function() {

      var a = update([__method.bind(this)], arguments);

      return wrapper.apply(this, a);

    }

  }

  function methodize() {

    if (this._methodized) return this._methodized;

    var __method = this;

    return this._methodized = function() {

      var a = update([this], arguments);

      return __method.apply(null, a);

    };

  }

  return {

    argumentNames:       argumentNames,

    bind:                bind,

    bindAsEventListener: bindAsEventListener,

    curry:               curry,

    delay:               delay,

    defer:               defer,

    wrap:                wrap,

    methodize:           methodize

  }

})());

(function(proto) {

  function toISOString() {

    return this.getUTCFullYear() + '-' +

      (this.getUTCMonth() + 1).toPaddedString(2) + '-' +

      this.getUTCDate().toPaddedString(2) + 'T' +

      this.getUTCHours().toPaddedString(2) + ':' +

      this.getUTCMinutes().toPaddedString(2) + ':' +

      this.getUTCSeconds().toPaddedString(2) + 'Z';

  }

  function toJSON() {

    return this.toISOString();

  }

  if (!proto.toISOString) proto.toISOString = toISOString;

  if (!proto.toJSON) proto.toJSON = toJSON;

})(Date.prototype);

RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {

  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');

};

var PeriodicalExecuter = Class.create({

  initialize: function(callback, frequency) {

    this.callback = callback;

    this.frequency = frequency;

    this.currentlyExecuting = false;

    this.registerCallback();

  },

  registerCallback: function() {

    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);

  },

  execute: function() {

    this.callback(this);

  },

  stop: function() {

    if (!this.timer) return;

    clearInterval(this.timer);

    this.timer = null;

  },

  onTimerEvent: function() {

    if (!this.currentlyExecuting) {

      try {

        this.currentlyExecuting = true;

        this.execute();

        this.currentlyExecuting = false;

      } catch(e) {

        this.currentlyExecuting = false;

        throw e;

      }

    }

  }

});

Object.extend(String, {

  interpret: function(value) {

    return value == null ? '' : String(value);

  },

  specialChar: {

    '\b': '\\b',

    '\t': '\\t',

    '\n': '\\n',

    '\f': '\\f',

    '\r': '\\r',

    '\\': '\\\\'

  }

});

Object.extend(String.prototype, (function() {

  var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&

    typeof JSON.parse === 'function' &&

    JSON.parse('{"test": true}').test;

  function prepareReplacement(replacement) {

    if (Object.isFunction(replacement)) return replacement;

    var template = new Template(replacement);

    return function(match) { return template.evaluate(match) };

  }

  function gsub(pattern, replacement) {

    var result = '', source = this, match;

    replacement = prepareReplacement(replacement);

    if (Object.isString(pattern))

      pattern = RegExp.escape(pattern);

    if (!(pattern.length || pattern.source)) {

      replacement = replacement('');

      return replacement + source.split('').join(replacement) + replacement;

    }

    while (source.length > 0) {

      if (match = source.match(pattern)) {

        result += source.slice(0, match.index);

        result += String.interpret(replacement(match));

        source  = source.slice(match.index + match[0].length);

      } else {

        result += source, source = '';

      }

    }

    return result;

  }

  function sub(pattern, replacement, count) {

    replacement = prepareReplacement(replacement);

    count = Object.isUndefined(count) ? 1 : count;

    return this.gsub(pattern, function(match) {

      if (--count < 0) return match[0];

      return replacement(match);

    });

  }

  function scan(pattern, iterator) {

    this.gsub(pattern, iterator);

    return String(this);

  }

  function truncate(length, truncation) {

    length = length || 30;

    truncation = Object.isUndefined(truncation) ? '...' : truncation;

    return this.length > length ?

      this.slice(0, length - truncation.length) + truncation : String(this);

  }

  function strip() {

    return this.replace(/^\s+/, '').replace(/\s+$/, '');

  }

  function stripTags() {

    return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');

  }

  function stripScripts() {

    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');

  }

  function extractScripts() {

    var matchAll = new RegExp(Prototype.ScriptFragment, 'img'),

        matchOne = new RegExp(Prototype.ScriptFragment, 'im');

    return (this.match(matchAll) || []).map(function(scriptTag) {

      return (scriptTag.match(matchOne) || ['', ''])[1];

    });

  }

  function evalScripts() {

    return this.extractScripts().map(function(script) { return eval(script) });

  }

  function escapeHTML() {

    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');

  }

  function unescapeHTML() {

    return this.stripTags().replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');

  }

  function toQueryParams(separator) {

    var match = this.strip().match(/([^?#]*)(#.*)?$/);

    if (!match) return { };

    return match[1].split(separator || '&').inject({ }, function(hash, pair) {

      if ((pair = pair.split('='))[0]) {

        var key = decodeURIComponent(pair.shift()),

            value = pair.length > 1 ? pair.join('=') : pair[0];

        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {

          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];

          hash[key].push(value);

        }

        else hash[key] = value;

      }

      return hash;

    });

  }

  function toArray() {

    return this.split('');

  }

  function succ() {

    return this.slice(0, this.length - 1) +

      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);

  }

  function times(count) {

    return count < 1 ? '' : new Array(count + 1).join(this);

  }

  function camelize() {

    return this.replace(/-+(.)?/g, function(match, chr) {

      return chr ? chr.toUpperCase() : '';

    });

  }

  function capitalize() {

    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();

  }

  function underscore() {

    return this.replace(/::/g, '/')

               .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')

               .replace(/([a-z\d])([A-Z])/g, '$1_$2')

               .replace(/-/g, '_')

               .toLowerCase();

  }

  function dasherize() {

    return this.replace(/_/g, '-');

  }

  function inspect(useDoubleQuotes) {

    var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {

      if (character in String.specialChar) {

        return String.specialChar[character];

      }

      return '\\u00' + character.charCodeAt().toPaddedString(2, 16);

    });

    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';

    return "'" + escapedString.replace(/'/g, '\\\'') + "'";

  }

  function unfilterJSON(filter) {

    return this.replace(filter || Prototype.JSONFilter, '$1');

  }

  function isJSON() {

    var str = this;

    if (str.blank()) return false;

    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');

    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');

    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');

    return (/^[\],:{}\s]*$/).test(str);

  }

  function evalJSON(sanitize) {

    var json = this.unfilterJSON(),

        cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;

    if (cx.test(json)) {

      json = json.replace(cx, function (a) {

        return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);

      });

    }

    try {

      if (!sanitize || json.isJSON()) return eval('(' + json + ')');

    } catch (e) { }

    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());

  }

  function parseJSON() {

    var json = this.unfilterJSON();

    return JSON.parse(json);

  }

  function include(pattern) {

    return this.indexOf(pattern) > -1;

  }

  function startsWith(pattern) {

    return this.lastIndexOf(pattern, 0) === 0;

  }

  function endsWith(pattern) {

    var d = this.length - pattern.length;

    return d >= 0 && this.indexOf(pattern, d) === d;