chg: replaced ant with gradle

modules/jala/code/History.js

@@ -0,0 +1,253 @@
+//
+// Jala Project [http://opensvn.csie.org/traccgi/jala]
+//
+// Copyright 2004 ORF Online und Teletext GmbH
+//
+// Licensed 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.
+//
+// $Revision$
+// $LastChangedBy$
+// $LastChangedDate$
+// $HeadURL$
+//
+
+
+/**
+ * @fileoverview Fields and methods of the jala.History class.
+ */
+
+
+// Define the global namespace for Jala modules
+if (!global.jala) {
+   global.jala = {};
+}
+
+
+/**
+ * Constructs a new History object.
+ * @class This class is an implementation of a Browser-like history
+ * stack suitable to use in any Helma application. The difference
+ * to a Browser's history is that this implementation ignores
+ * POST requests and checks if Urls in the stack are still valid to
+ * prevent eg. redirections to a HopObject's url that has been deleted.
+ * Plus it is capable to create new "intermediate" history-stacks
+ * and this way maintain a "history of histories" which is needed for
+ * eg. editing sessions in a popup window that should use their own
+ * request history without interfering with the history of the
+ * main window.
+ * @constructor
+ */
+jala.History = function() {
+   var MAX = 40;
+
+   /**
+    * Stack constructor
+    * @private
+    */
+   var Stack = function(id) {
+      this.items = [];
+      this.id = id;
+      return this;
+   };
+
+   /**
+    * Returns the current url including query string
+    * @private
+    */
+   var getUrl = function() {
+      var query;
+      var url = path.href(req.action);
+      try {
+         if (query = req.getServletRequest().getQueryString())
+            url += "?" + query;
+      } catch (e) {
+         // ignore
+      }
+      return url;
+   }
+
+   /**
+    * Checks if a request is valid for being added
+    * to the history stack. This method returns false
+    * for all POST-requests or requests whose action name
+    * contains a dot (to prevent requests for external stylesheets
+    * or the like from being recorded).
+    * @private
+    * @type Boolean
+    */
+   var isValid = function() {
+      // FIXME: we should check for mimetype of response instead
+      // of assuming that requests containing a dot aren't worth
+      // being put into history stack ...
+      if (req.isPost() || (req.action && req.action.contains(".")))
+         return false;
+      return true;
+   };
+
+   /**
+    * returns a single Stack instance
+    * @private
+    */
+   var getStack = function() {
+      if (history.length < 1)
+         history.push(new Stack(getUrl()));
+      return history[history.length -1];
+   };
+
+   /**
+    * Variable containing the history-stacks
+    * @private
+    */
+   var history = [];
+
+   /**
+    * Initializes a new history stack, adds
+    * it to the array of stacks (which makes it
+    * the default one to use for further requests)
+    * and records the current request Url.
+    */
+   this.add = function() {
+      if (!isValid())
+         return;
+      var url = getUrl();
+      if (getStack().id != url) {
+         history.push(new Stack(url));
+         this.push();
+      }
+      return;
+   };
+
+   /**
+    * Removes the current history stack
+    */
+   this.remove = function() {
+      history.pop();
+      return;
+   };
+
+   /**
+    * Records a request Url in the currently active
+    * history stack.
+    */
+   this.push = function() {
+      if (isValid()) {
+         var obj = path[path.length-1];
+         var url = getUrl();
+         var stack = getStack();
+         if (stack.items.length < 1 || stack.items[stack.items.length -1].url != url) {
+            if (stack.items.length >= MAX)
+               stack.items.shift();
+            stack.items.push({
+               url: url,
+               path: path.href().substring(root.href().length).replace(/\+/g, " ")
+            });
+         }
+      }
+      return;
+   };
+   
+   /**
+    * Clears the currently active history stack
+    */
+   this.clear = function() {
+      getStack().items.length = 0;
+      return;
+   };   
+
+   /**
+    * Redirects the client back to the first valid
+    * request in history. Please mind that searching for
+    * a valid Url starts at <em>history.length - 2</em>.
+    * @param {Number} offset The index position in the stack to start
+    * searching at
+    */
+   this.redirect = function(offset) {
+      res.redirect(this.pop(offset));
+      return;
+   };
+   
+   /**
+    * Retrieves the first valid request Url in history
+    * stack starting with a given offset. The default offset is 1.
+    * Any valid Url found is removed from the stack, therefor
+    * this method <em>alters the contents of the history stack</em>.
+    * @param {Number} offset The index position in history stack to start
+    * searching at
+    * @return The Url of the request
+    * @type String
+    */
+   this.pop = function(offset) {
+      /**
+       * checks if a referrer is stil valid
+       * @private
+       */
+      var isValidPath = function(p) {
+         var arr = p.split("/");
+         var obj = root;
+         for (var i=0;i<arr.length -1;i++) {
+            if (!(obj = obj.get(unescape(arr[i]))) || obj.__node__.getState() == 3)
+               return false;
+         }
+         return true;
+      };
+
+      var obj;
+      var cut = offset != null ? offset : 1;
+      var stack = getStack();
+      if (stack.items.length > 0) {
+         while (cut-- > 0) {
+            obj = stack.items.pop();
+         }
+      }
+      while (stack.items.length > 0) {
+         obj = stack.items.pop();
+         // check if url is valid
+         if (isValidPath(obj.path)) {
+            return obj.url;
+         }
+      }
+      return path.href();
+   };
+
+   /**
+    * Retrieves the request Url at the given position
+    * in the current history stack. If no offset is given
+    * the last Url in the stack is returned. This method
+    * <em>does not alter the stack contents</em>!
+    * @param {Number} offset The index position in history stack to start
+    * searching at
+    * @return The Url of the request
+    * @type String
+    */
+   this.peek = function(offset) {
+      var stack = getStack();
+      return stack.items[stack.items.length - (offset != null ? offset : 1)];
+   };
+
+   /**
+    * Returns the contents of all history stacks
+    * as string
+    * @return The history stacks as string
+    * @type String
+    */
+   this.dump = function() {
+      return history.toSource();
+   };
+
+   /** @ignore */
+   this.toString = function() {
+      return "[History " + getStack().toSource() + "]";
+   };
+
+   return this;
+}