Add function to find the Sone ID of a Sone context menu.
[Sone.git] / 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 }();