src/main/resources/static/javascript/jquery.url.js

   1 // JQuery URL Parser
   2 // Written by Mark Perkins, mark@allmarkedup.com
   3 // License: http://unlicense.org/ (i.e. do what you want with it!)
   4
   5 jQuery.url = function()
   6 {
   7         var segments = {};
   8
   9         var parsed = {};
  10
  11         /**
  12     * Options object. Only the URI and strictMode values can be changed via the setters below.
  13     */
  14         var options = {
  15
  16                 url : window.location, // default URI is the page in which the script is running
  17
  18                 strictMode: false, // 'loose' parsing by default
  19
  20                 key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"], // keys available to query
  21
  22                 q: {
  23                         name: "queryKey",
  24                         parser: /(?:^|&)([^&=]*)=?([^&]*)/g
  25                 },
  26
  27                 parser: {
  28                         strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,  //less intuitive, more accurate to the specs
  29                         loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/ // more intuitive, fails on relative paths and deviates from specs
  30                 }
  31
  32         };
  33
  34     /**
  35      * Deals with the parsing of the URI according to the regex above.
  36          * Written by Steven Levithan - see credits at top.
  37      */
  38         var parseUri = function()
  39         {
  40                 str = decodeURI( options.url );
  41
  42                 var m = options.parser[ options.strictMode ? "strict" : "loose" ].exec( str );
  43                 var uri = {};
  44                 var i = 14;
  45
  46                 while ( i-- ) {
  47                         uri[ options.key[i] ] = m[i] || "";
  48                 }
  49
  50                 uri[ options.q.name ] = {};
  51                 uri[ options.key[12] ].replace( options.q.parser, function ( $0, $1, $2 ) {
  52                         if ($1) {
  53                                 uri[options.q.name][$1] = $2;
  54                         }
  55                 });
  56
  57                 return uri;
  58         };
  59
  60     /**
  61      * Returns the value of the passed in key from the parsed URI.
  62          *
  63          * @param string key The key whose value is required
  64      */
  65         var key = function( key )
  66         {
  67                 if ( jQuery.isEmptyObject(parsed) )
  68                 {
  69                         setUp(); // if the URI has not been parsed yet then do this first...
  70                 }
  71                 if ( key == "base" )
  72                 {
  73                         if ( parsed.port !== null && parsed.port !== "" )
  74                         {
  75                                 return parsed.protocol+"://"+parsed.host+":"+parsed.port+"/";
  76                         }
  77                         else
  78                         {
  79                                 return parsed.protocol+"://"+parsed.host+"/";
  80                         }
  81                 }
  82
  83                 return ( parsed[key] === "" ) ? null : parsed[key];
  84         };
  85
  86         /**
  87      * Returns the value of the required query string parameter.
  88          *
  89          * @param string item The parameter whose value is required
  90      */
  91         var param = function( item )
  92         {
  93                 if ( jQuery.isEmptyObject(parsed) )
  94                 {
  95                         setUp(); // if the URI has not been parsed yet then do this first...
  96                 }
  97                 return ( parsed.queryKey[item] === null ) ? null : parsed.queryKey[item];
  98         };
  99
 100     /**
 101      * 'Constructor' (not really!) function.
 102      *  Called whenever the URI changes to kick off re-parsing of the URI and splitting it up into segments.
 103      */
 104         var setUp = function()
 105         {
 106                 parsed = parseUri();
 107
 108                 getSegments();
 109         };
 110
 111     /**
 112      * Splits up the body of the URI into segments (i.e. sections delimited by '/')
 113      */
 114         var getSegments = function()
 115         {
 116                 var p = parsed.path;
 117                 segments = []; // clear out segments array
 118                 segments = parsed.path.length == 1 ? {} : ( p.charAt( p.length - 1 ) == "/" ? p.substring( 1, p.length - 1 ) : path = p.substring( 1 ) ).split("/");
 119         };
 120
 121         return {
 122
 123             /**
 124              * Sets the parsing mode - either strict or loose. Set to loose by default.
 125              *
 126              * @param string mode The mode to set the parser to. Anything apart from a value of 'strict' will set it to loose!
 127              */
 128                 setMode : function( mode )
 129                 {
 130                         options.strictMode = mode == "strict" ? true : false;
 131                         return this;
 132                 },
 133
 134                 /**
 135              * Sets URI to parse if you don't want to to parse the current page's URI.
 136                  * Calling the function with no value for newUri resets it to the current page's URI.
 137              *
 138              * @param string newUri The URI to parse.
 139              */
 140                 setUrl : function( newUri )
 141                 {
 142                         options.url = newUri === undefined ? window.location : newUri;
 143                         setUp();
 144                         return this;
 145                 },
 146
 147                 /**
 148              * Returns the value of the specified URI segment. Segments are numbered from 1 to the number of segments.
 149                  * For example the URI http://test.com/about/company/ segment(1) would return 'about'.
 150                  *
 151                  * If no integer is passed into the function it returns the number of segments in the URI.
 152              *
 153              * @param int pos The position of the segment to return. Can be empty.
 154              */
 155                 segment : function( pos )
 156                 {
 157                         if ( jQuery.isEmptyObject(parsed) )
 158                         {
 159                                 setUp(); // if the URI has not been parsed yet then do this first...
 160                         }
 161                         if ( pos === undefined )
 162                         {
 163                                 return segments.length;
 164                         }
 165                         return ( segments[pos] === "" || segments[pos] === undefined ) ? null : segments[pos];
 166                 },
 167
 168                 attr : key, // provides public access to private 'key' function - see above
 169
 170                 param : param // provides public access to private 'param' function - see above
 171
 172         };
 173
 174 }();