rjack-solr 3.6.2.0-java → 4.0.0.0-java

data/webapp/js/lib/jquery.timeago.js

@@ -0,0 +1,165 @@
+/*
+ * timeago: a jQuery plugin, version: 0.9.3 (2011-01-21)
+ * @requires jQuery v1.2.3 or later
+ *
+ * Timeago is a jQuery plugin that makes it easy to support automatically
+ * updating fuzzy timestamps (e.g. "4 minutes ago" or "about 1 day ago").
+ *
+ * For usage and examples, visit:
+ * http://timeago.yarp.com/
+ *
+ * Licensed under the MIT:
+ * http://www.opensource.org/licenses/mit-license.php
+ *
+ * Copyright (c) 2008-2011, Ryan McGeary (ryanonjavascript -[at]- mcgeary [*dot*] org)
+ */
+
+(function($) {
+  $.timeago = function(timestamp) {
+    if (timestamp instanceof Date) {
+      return inWords(timestamp);
+    } else if (typeof timestamp === "string") {
+      return inWords($.timeago.parse(timestamp));
+    } else {
+      return inWords($.timeago.datetime(timestamp));
+    }
+  };
+  var $t = $.timeago;
+
+  $.extend($.timeago, {
+    settings: {
+      refreshMillis: 60000,
+      allowFuture: false,
+      strings: {
+        prefixAgo: null,
+        prefixFromNow: null,
+        suffixAgo: "ago",
+        suffixFromNow: "from now",
+        seconds: "less than a minute",
+        minute: "about a minute",
+        minutes: "%d minutes",
+        hour: "about an hour",
+        hours: "about %d hours",
+        day: "a day",
+        days: "%d days",
+        month: "about a month",
+        months: "%d months",
+        year: "about a year",
+        years: "%d years",
+        numbers: []
+      }
+    },
+    inWords: function(distanceMillis) {
+      var $l = this.settings.strings;
+      var prefix = $l.prefixAgo;
+      var suffix = $l.suffixAgo;
+      if (this.settings.allowFuture) {
+        if (distanceMillis < 0) {
+          prefix = $l.prefixFromNow;
+          suffix = $l.suffixFromNow;
+        }
+        distanceMillis = Math.abs(distanceMillis);
+      }
+
+      var seconds = distanceMillis / 1000;
+      var minutes = seconds / 60;
+      var hours = minutes / 60;
+      var days = hours / 24;
+      var years = days / 365;
+
+      function substitute(stringOrFunction, number) {
+        var string = $.isFunction(stringOrFunction) ? stringOrFunction(number, distanceMillis) : stringOrFunction;
+        var value = ($l.numbers && $l.numbers[number]) || number;
+        return string.replace(/%d/i, value);
+      }
+
+      var words = seconds < 45 && substitute($l.seconds, Math.round(seconds)) ||
+        seconds < 90 && substitute($l.minute, 1) ||
+        minutes < 45 && substitute($l.minutes, Math.round(minutes)) ||
+        minutes < 90 && substitute($l.hour, 1) ||
+        hours < 24 && substitute($l.hours, Math.round(hours)) ||
+        hours < 48 && substitute($l.day, 1) ||
+        days < 30 && substitute($l.days, Math.floor(days)) ||
+        days < 60 && substitute($l.month, 1) ||
+        days < 365 && substitute($l.months, Math.floor(days / 30)) ||
+        years < 2 && substitute($l.year, 1) ||
+        substitute($l.years, Math.floor(years));
+
+      return $.trim([prefix, words, suffix].join(" "));
+    },
+    parse: function(iso8601) {
+      var s = $.trim(iso8601);
+      s = s.replace(/\.\d\d\d+/,""); // remove milliseconds
+      s = s.replace(/-/g,"/");
+      s = s.replace(/(\d)T(\d)/,"$1 $2").replace(/(\d)Z/,"$1 UTC");
+      s = s.replace(/([\+\-]\d\d)\:?(\d\d)/," $1$2"); // -04:00 -> -0400
+      return new Date(s);
+    },
+    datetime: function(elem) {
+      // jQuery's `is()` doesn't play well with HTML5 in IE
+      var isTime = $(elem).get(0).tagName.toLowerCase() === "time"; // $(elem).is("time");
+      
+      var iso8601 = null;
+      
+      if( isTime )
+      {
+        iso8601 = $(elem).attr("datetime");
+      }
+      
+      if( !iso8601 )
+      {
+        iso8601 = $(elem).attr("title");
+      }
+      
+      if( !iso8601 )
+      {
+        iso8601 = $(elem).text();
+      }
+      
+      return $t.parse(iso8601);
+    }
+  });
+
+  $.fn.timeago = function() {
+    var self = this;
+    self.each(refresh);
+
+    var $s = $t.settings;
+    if ($s.refreshMillis > 0) {
+      setInterval(function() { self.each(refresh); }, $s.refreshMillis);
+    }
+    return self;
+  };
+
+  function refresh() {
+    var data = prepareData(this);
+    if (!isNaN(data.datetime)) {
+      $(this).text(inWords(data.datetime));
+    }
+    return this;
+  }
+
+  function prepareData(element) {
+    element = $(element);
+    if (!element.data("timeago")) {
+      element.data("timeago", { datetime: $t.datetime(element) });
+      var text = $.trim(element.text());
+      if (text.length > 0) {
+        element.attr("title", text);
+      }
+    }
+    return element.data("timeago");
+  }
+
+  function inWords(date) {
+    return $t.inWords(distance(date));
+  }
+
+  function distance(date) {
+    return (new Date().getTime() - date.getTime());
+  }
+
+  // fix for IE6 suckage
+  document.createElement("abbr");
+  document.createElement("time");
+}(jQuery));

data/webapp/js/lib/linker.js

@@ -0,0 +1,48 @@
+//by Michalis Tzikas & Vasilis Lolos
+//07-03-2012
+//v1.0
+/*
+Copyright (C) 2011 by Michalis Tzikas & Vasilis Lolos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+(function( $ ){
+  $.fn.linker = function(options) {
+    var defaults = {
+      target   : '', //blank,self,parent,top
+      className : '',
+      rel : ''
+    };
+    var options = $.extend(defaults, options);
+        
+    target_string = (options.target != '') ? 'target="_'+options.target+'"' : '';
+    class_string  = (options.className != '') ? 'class="'+options.className+'"' : '';
+    rel_string    = (options.rel != '') ? 'rel="'+options.rel+'"' : '';
+
+    $(this).each(function(){
+      t = $(this).text();
+      
+      t = t.replace(/(https\:\/\/|http:\/\/)([www\.]?)([^\s|<]+)/gi,'<a href="$1$2$3" '+target_string+' '+class_string+' '+rel_string+'>$1$2$3</a>');
+      t = t.replace(/([^https\:\/\/]|[^http:\/\/]|^)(www)\.([^\s|<]+)/gi,'$1<a href="http://$2.$3" '+target_string+' '+class_string+' '+rel_string+'>$2.$3</a>');
+      t = t.replace(/<([^a]|^\/a])([^<>]+)>/g, "&lt;$1$2&gt;").replace(/&lt;\/a&gt;/g, "</a>").replace(/<(.)>/g, "&lt;$1&gt;").replace(/\n/g, '<br />');
+
+      $(this).html(t);
+    });
+  };
+})( jQuery );

data/webapp/js/lib/order.js

@@ -0,0 +1,189 @@
+/**
+ * @license RequireJS order 1.0.5 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+/*jslint nomen: false, plusplus: false, strict: false */
+/*global require: false, define: false, window: false, document: false,
+  setTimeout: false */
+
+//Specify that requirejs optimizer should wrap this code in a closure that
+//maps the namespaced requirejs API to non-namespaced local variables.
+/*requirejs namespace: true */
+
+(function () {
+
+    //Sadly necessary browser inference due to differences in the way
+    //that browsers load and execute dynamically inserted javascript
+    //and whether the script/cache method works when ordered execution is
+    //desired. Currently, Gecko and Opera do not load/fire onload for scripts with
+    //type="script/cache" but they execute injected scripts in order
+    //unless the 'async' flag is present.
+    //However, this is all changing in latest browsers implementing HTML5
+    //spec. With compliant browsers .async true by default, and
+    //if false, then it will execute in order. Favor that test first for forward
+    //compatibility.
+    var testScript = typeof document !== "undefined" &&
+                 typeof window !== "undefined" &&
+                 document.createElement("script"),
+
+        supportsInOrderExecution = testScript && (testScript.async ||
+                               ((window.opera &&
+                                 Object.prototype.toString.call(window.opera) === "[object Opera]") ||
+                               //If Firefox 2 does not have to be supported, then
+                               //a better check may be:
+                               //('mozIsLocallyAvailable' in window.navigator)
+                               ("MozAppearance" in document.documentElement.style))),
+
+        //This test is true for IE browsers, which will load scripts but only
+        //execute them once the script is added to the DOM.
+        supportsLoadSeparateFromExecute = testScript &&
+                                          testScript.readyState === 'uninitialized',
+
+        readyRegExp = /^(complete|loaded)$/,
+        cacheWaiting = [],
+        cached = {},
+        scriptNodes = {},
+        scriptWaiting = [];
+
+    //Done with the test script.
+    testScript = null;
+
+    //Callback used by the type="script/cache" callback that indicates a script
+    //has finished downloading.
+    function scriptCacheCallback(evt) {
+        var node = evt.currentTarget || evt.srcElement, i,
+            moduleName, resource;
+
+        if (evt.type === "load" || readyRegExp.test(node.readyState)) {
+            //Pull out the name of the module and the context.
+            moduleName = node.getAttribute("data-requiremodule");
+
+            //Mark this cache request as loaded
+            cached[moduleName] = true;
+
+            //Find out how many ordered modules have loaded
+            for (i = 0; (resource = cacheWaiting[i]); i++) {
+                if (cached[resource.name]) {
+                    resource.req([resource.name], resource.onLoad);
+                } else {
+                    //Something in the ordered list is not loaded,
+                    //so wait.
+                    break;
+                }
+            }
+
+            //If just loaded some items, remove them from cacheWaiting.
+            if (i > 0) {
+                cacheWaiting.splice(0, i);
+            }
+
+            //Remove this script tag from the DOM
+            //Use a setTimeout for cleanup because some older IE versions vomit
+            //if removing a script node while it is being evaluated.
+            setTimeout(function () {
+                node.parentNode.removeChild(node);
+            }, 15);
+        }
+    }
+
+    /**
+     * Used for the IE case, where fetching is done by creating script element
+     * but not attaching it to the DOM. This function will be called when that
+     * happens so it can be determined when the node can be attached to the
+     * DOM to trigger its execution.
+     */
+    function onFetchOnly(node) {
+        var i, loadedNode, resourceName;
+
+        //Mark this script as loaded.
+        node.setAttribute('data-orderloaded', 'loaded');
+
+        //Cycle through waiting scripts. If the matching node for them
+        //is loaded, and is in the right order, add it to the DOM
+        //to execute the script.
+        for (i = 0; (resourceName = scriptWaiting[i]); i++) {
+            loadedNode = scriptNodes[resourceName];
+            if (loadedNode &&
+                loadedNode.getAttribute('data-orderloaded') === 'loaded') {
+                delete scriptNodes[resourceName];
+                require.addScriptToDom(loadedNode);
+            } else {
+                break;
+            }
+        }
+
+        //If just loaded some items, remove them from waiting.
+        if (i > 0) {
+            scriptWaiting.splice(0, i);
+        }
+    }
+
+    define({
+        version: '1.0.5',
+
+        load: function (name, req, onLoad, config) {
+            var hasToUrl = !!req.nameToUrl,
+                url, node, context;
+
+            //If no nameToUrl, then probably a build with a loader that
+            //does not support it, and all modules are inlined.
+            if (!hasToUrl) {
+                req([name], onLoad);
+                return;
+            }
+
+            url = req.nameToUrl(name, null);
+
+            //Make sure the async attribute is not set for any pathway involving
+            //this script.
+            require.s.skipAsync[url] = true;
+            if (supportsInOrderExecution || config.isBuild) {
+                //Just a normal script tag append, but without async attribute
+                //on the script.
+                req([name], onLoad);
+            } else if (supportsLoadSeparateFromExecute) {
+                //Just fetch the URL, but do not execute it yet. The
+                //non-standards IE case. Really not so nice because it is
+                //assuming and touching requrejs internals. OK though since
+                //ordered execution should go away after a long while.
+                context = require.s.contexts._;
+
+                if (!context.urlFetched[url] && !context.loaded[name]) {
+                    //Indicate the script is being fetched.
+                    context.urlFetched[url] = true;
+
+                    //Stuff from require.load
+                    require.resourcesReady(false);
+                    context.scriptCount += 1;
+
+                    //Fetch the script now, remember it.
+                    node = require.attach(url, context, name, null, null, onFetchOnly);
+                    scriptNodes[name] = node;
+                    scriptWaiting.push(name);
+                }
+
+                //Do a normal require for it, once it loads, use it as return
+                //value.
+                req([name], onLoad);
+            } else {
+                //Credit to LABjs author Kyle Simpson for finding that scripts
+                //with type="script/cache" allow scripts to be downloaded into
+                //browser cache but not executed. Use that
+                //so that subsequent addition of a real type="text/javascript"
+                //tag will cause the scripts to be executed immediately in the
+                //correct order.
+                if (req.specified(name)) {
+                    req([name], onLoad);
+                } else {
+                    cacheWaiting.push({
+                        name: name,
+                        req: req,
+                        onLoad: onLoad
+                    });
+                    require.attach(url, null, name, scriptCacheCallback, "script/cache");
+                }
+            }
+        }
+    });
+}());

data/webapp/js/main.js

@@ -0,0 +1,57 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+require
+(
+  [
+    'lib/order!lib/console',
+    'lib/order!jquery',
+    'lib/order!lib/jquery.cookie',
+    'lib/order!lib/jquery.form',
+    'lib/order!lib/jquery.jstree',
+    'lib/order!lib/jquery.sammy',
+    'lib/order!lib/jquery.sparkline',
+    'lib/order!lib/jquery.timeago',
+    'lib/order!lib/jquery.blockUI',
+    'lib/order!lib/highlight',
+    'lib/order!lib/linker',
+    'lib/order!lib/ZeroClipboard',
+    'lib/order!lib/d3',
+    'lib/order!lib/chosen',
+    'lib/order!scripts/app',
+
+    'lib/order!scripts/analysis',
+    'lib/order!scripts/cloud',
+    'lib/order!scripts/cores',
+    'lib/order!scripts/dataimport',
+    'lib/order!scripts/dashboard',
+    'lib/order!scripts/file',
+    'lib/order!scripts/index',
+    'lib/order!scripts/java-properties',
+    'lib/order!scripts/logging',
+    'lib/order!scripts/ping',
+    'lib/order!scripts/plugins',
+    'lib/order!scripts/query',
+    'lib/order!scripts/replication',
+    'lib/order!scripts/schema-browser',
+    'lib/order!scripts/threads'
+  ],
+  function( $ )
+  {
+    app.run();
+  }
+);