872f43299199b219530c5ee0f057390f2f1874dd
[jalview.git] / UrlLink.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.util;
22
23 import static jalview.util.UrlConstants.SEQUENCE_ID;
24 import static jalview.util.UrlConstants.SEQUENCE_NAME;
25
26 import java.util.Vector;
27
28 public class UrlLink
29 {
30   /**
31    * helper class to parse URL Link strings taken from applet parameters or
32    * jalview properties file using the com.stevesoft.pat.Regex implementation.
33    * Jalview 2.4 extension allows regular expressions to be used to parse ID
34    * strings and replace the result in the URL. Regex's operate on the whole ID
35    * string given to the matchURL method, if no regex is supplied, then only
36    * text following the first pipe symbol will be susbstituted. Usage
37    * documentation todo.
38    */
39   private String url_suffix, url_prefix, target, label, regexReplace;
40
41   private boolean dynamic = false;
42
43   private boolean uses_seq_id = false;
44
45   private String invalidMessage = null;
46
47   /**
48    * parse the given linkString of the form '<label>|<url>' into parts url may
49    * contain a string $SEQUENCE_ID<=optional regex=>$ where <=optional regex=>
50    * must be of the form =/<perl style regex>/=$
51    * 
52    * @param link
53    */
54   public UrlLink(String link)
55   {
56     int sep = link.indexOf("|");
57     int psqid = link.indexOf("$" + SEQUENCE_ID);
58     int nsqid = link.indexOf("$" + SEQUENCE_NAME);
59     if (psqid > -1)
60     {
61       dynamic = true;
62       uses_seq_id = true;
63
64       sep = parseTargetAndLabel(sep, psqid, link);
65
66       parseUrl(link, SEQUENCE_ID, psqid, sep);
67     }
68     else if (nsqid > -1)
69     {
70       dynamic = true;
71       sep = parseTargetAndLabel(sep, nsqid, link);
72
73       parseUrl(link, SEQUENCE_NAME, nsqid, sep);
74     }
75     else
76     {
77       target = link.substring(0, sep);
78       sep = link.lastIndexOf("|");
79       label = link.substring(0, sep);
80       url_prefix = link.substring(sep + 1);
81       regexReplace = null; // implies we trim any prefix if necessary //
82       // regexReplace=".*\\|?(.*)";
83       url_suffix = null;
84     }
85
86     label = label.trim();
87     target = target.trim();
88     target = target.toUpperCase(); // DBRefEntry uppercases DB names
89     // NB getCanonicalName might be better but does not currently change case
90   }
91
92   /**
93    * @return the url_suffix
94    */
95   public String getUrl_suffix()
96   {
97     return url_suffix;
98   }
99
100   /**
101    * @return the url_prefix
102    */
103   public String getUrl_prefix()
104   {
105     return url_prefix;
106   }
107
108   /**
109    * @return the target
110    */
111   public String getTarget()
112   {
113     return target;
114   }
115
116   /**
117    * @return the label
118    */
119   public String getLabel()
120   {
121     return label;
122   }
123
124   /**
125    * @return the regexReplace
126    */
127   public String getRegexReplace()
128   {
129     return regexReplace;
130   }
131
132   /**
133    * @return the invalidMessage
134    */
135   public String getInvalidMessage()
136   {
137     return invalidMessage;
138   }
139
140   /**
141    * Check if URL string was parsed properly.
142    * 
143    * @return boolean - if false then <code>getInvalidMessage</code> returns an
144    *         error message
145    */
146   public boolean isValid()
147   {
148     return invalidMessage == null;
149   }
150
151   /**
152    * return one or more URL strings by applying regex to the given idstring
153    * 
154    * @param idstring
155    * @param onlyIfMatches
156    *          - when true url strings are only made if regex is defined and
157    *          matches
158    * @return String[] { part of idstring substituted, full substituted url , ..
159    *         next part, next url..}
160    */
161   public String[] makeUrls(String idstring, boolean onlyIfMatches)
162   {
163     if (dynamic)
164     {
165       if (regexReplace != null)
166       {
167         com.stevesoft.pat.Regex rg = com.stevesoft.pat.Regex.perlCode("/"
168                 + regexReplace + "/");
169         if (rg.search(idstring))
170         {
171           int ns = rg.numSubs();
172           if (ns == 0)
173           {
174             // take whole regex
175             return new String[] { rg.stringMatched(),
176                 url_prefix + rg.stringMatched() + url_suffix };
177           } /*
178              * else if (ns==1) { // take only subgroup match return new String[]
179              * { rg.stringMatched(1), url_prefix+rg.stringMatched(1)+url_suffix
180              * }; }
181              */
182           else
183           {
184             // debug
185             for (int s = 0; s <= rg.numSubs(); s++)
186             {
187               System.err.println("Sub " + s + " : " + rg.matchedFrom(s)
188                       + " : " + rg.matchedTo(s) + " : '"
189                       + rg.stringMatched(s) + "'");
190             }
191             // try to collate subgroup matches
192             Vector subs = new Vector();
193             // have to loop through submatches, collating them at top level
194             // match
195             int s = 0; // 1;
196             while (s <= ns)
197             {
198               if (s + 1 <= ns && rg.matchedTo(s) > -1
199                       && rg.matchedTo(s + 1) > -1
200                       && rg.matchedTo(s + 1) < rg.matchedTo(s))
201               {
202                 // s is top level submatch. search for submatches enclosed by
203                 // this one
204                 int r = s + 1;
205                 String mtch = "";
206                 while (r <= ns && rg.matchedTo(r) <= rg.matchedTo(s))
207                 {
208                   if (rg.matchedFrom(r) > -1)
209                   {
210                     mtch += rg.stringMatched(r);
211                   }
212                   r++;
213                 }
214                 if (mtch.length() > 0)
215                 {
216                   subs.addElement(mtch);
217                   subs.addElement(url_prefix + mtch + url_suffix);
218                 }
219                 s = r;
220               }
221               else
222               {
223                 if (rg.matchedFrom(s) > -1)
224                 {
225                   subs.addElement(rg.stringMatched(s));
226                   subs.addElement(url_prefix + rg.stringMatched(s)
227                           + url_suffix);
228                 }
229                 s++;
230               }
231             }
232
233             String[] res = new String[subs.size()];
234             for (int r = 0, rs = subs.size(); r < rs; r++)
235             {
236               res[r] = (String) subs.elementAt(r);
237             }
238             subs.removeAllElements();
239             return res;
240           }
241         }
242         if (onlyIfMatches)
243         {
244           return null;
245         }
246       }
247       /* Otherwise - trim off any 'prefix' - pre 2.4 Jalview behaviour */
248       if (idstring.indexOf("|") > -1)
249       {
250         idstring = idstring.substring(idstring.lastIndexOf("|") + 1);
251       }
252
253       // just return simple url substitution.
254       return new String[] { idstring, url_prefix + idstring + url_suffix };
255     }
256     else
257     {
258       return new String[] { "", url_prefix };
259     }
260   }
261
262   @Override
263   public String toString()
264   {
265     String var = (uses_seq_id ? SEQUENCE_ID : SEQUENCE_NAME);
266
267     return label
268             + "|"
269             + url_prefix
270             + (dynamic ? ("$" + var + ((regexReplace != null) ? "="
271                     + regexReplace + "=$" : "$")) : "")
272             + ((url_suffix == null) ? "" : url_suffix);
273   }
274
275   /**
276    * 
277    * @param firstSep
278    *          Location of first occurrence of separator in link string
279    * @param psqid
280    *          Position of sequence id or name in link string
281    * @param link
282    *          Link string containing database name and url
283    * @return Position of last separator symbol prior to any regex symbols
284    */
285   protected int parseTargetAndLabel(int firstSep, int psqid, String link)
286   {
287     int p = firstSep;
288     int sep = firstSep;
289     do
290     {
291       sep = p;
292       p = link.indexOf("|", sep + 1);
293     } while (p > sep && p < psqid);
294     // Assuming that the URL itself does not contain any '|' symbols
295     // sep now contains last pipe symbol position prior to any regex symbols
296     label = link.substring(0, sep);
297     if (label.indexOf("|") > -1)
298     {
299       // | terminated database name / www target at start of Label
300       target = label.substring(0, label.indexOf("|"));
301     }
302     else if (label.indexOf(" ") > 2)
303     {
304       // space separated Label - matches database name
305       target = label.substring(0, label.indexOf(" "));
306     }
307     else
308     {
309       target = label;
310     }
311     return sep;
312   }
313
314   /**
315    * Parse the URL part of the link string
316    * 
317    * @param link
318    *          Link string containing database name and url
319    * @param varName
320    *          Name of variable in url string (e.g. SEQUENCE_ID, SEQUENCE_NAME)
321    * @param sqidPos
322    *          Position of id or name in link string
323    * @param sep
324    *          Position of separator in link string
325    */
326   protected void parseUrl(String link, String varName, int sqidPos, int sep)
327   {
328     url_prefix = link.substring(sep + 1, sqidPos);
329
330     // delimiter at start of regex: e.g. $SEQUENCE_ID=/
331     String startDelimiter = "$" + varName + "=/";
332
333     // delimiter at end of regex: /=$
334     String endDelimiter = "/=$";
335
336     int startLength = startDelimiter.length();
337
338     // Parse URL : Whole URL string first
339     int p = link.indexOf(endDelimiter, sqidPos + startLength);
340
341     if (link.indexOf(startDelimiter) == sqidPos
342             && (p > sqidPos + startLength))
343     {
344       // Extract Regex and suffix
345       url_suffix = link.substring(p + endDelimiter.length());
346       regexReplace = link.substring(sqidPos + startLength, p);
347       try
348       {
349         com.stevesoft.pat.Regex rg = com.stevesoft.pat.Regex.perlCode("/"
350                 + regexReplace + "/");
351         if (rg == null)
352         {
353           invalidMessage = "Invalid Regular Expression : '" + regexReplace
354                   + "'\n";
355         }
356       } catch (Exception e)
357       {
358         invalidMessage = "Invalid Regular Expression : '" + regexReplace
359                 + "'\n";
360       }
361     }
362     else
363     {
364       // no regex
365       regexReplace = null;
366       // verify format is really correct.
367       if (link.indexOf("$" + varName + "$") == sqidPos)
368       {
369         url_suffix = link.substring(sqidPos + startLength - 1);
370         regexReplace = null;
371       }
372       else
373       {
374         invalidMessage = "Warning: invalid regex structure for URL link : "
375                 + link;
376       }
377     }
378   }
379
380   private static void testUrls(UrlLink ul, String idstring, String[] urls)
381   {
382
383     if (urls == null)
384     {
385       System.out.println("Created NO urls.");
386     }
387     else
388     {
389       System.out.println("Created " + (urls.length / 2) + " Urls.");
390       for (int uls = 0; uls < urls.length; uls += 2)
391       {
392         System.out.println("URL Replacement text : " + urls[uls]
393                 + " : URL : " + urls[uls + 1]);
394       }
395     }
396   }
397
398   public static void main(String argv[])
399   {
400     String[] links = new String[] {
401     /*
402      * "AlinkT|Target|http://foo.foo.soo/",
403      * "myUrl1|http://$SEQUENCE_ID=/[0-9]+/=$.someserver.org/foo",
404      * "myUrl2|http://$SEQUENCE_ID=/(([0-9]+).+([A-Za-z]+))/=$.someserver.org/foo"
405      * ,
406      * "myUrl3|http://$SEQUENCE_ID=/([0-9]+).+([A-Za-z]+)/=$.someserver.org/foo"
407      * , "myUrl4|target|http://$SEQUENCE_ID$.someserver.org/foo|too",
408      * "PF1|http://us.expasy.org/cgi-bin/niceprot.pl?$SEQUENCE_ID=/(?:PFAM:)?(.+)/=$"
409      * ,
410      * "PF2|http://us.expasy.org/cgi-bin/niceprot.pl?$SEQUENCE_ID=/(PFAM:)?(.+)/=$"
411      * ,
412      * "PF3|http://us.expasy.org/cgi-bin/niceprot.pl?$SEQUENCE_ID=/PFAM:(.+)/=$"
413      * , "NOTFER|http://notfer.org/$SEQUENCE_ID=/(?<!\\s)(.+)/=$",
414      */
415     "NESTED|http://nested/$" + SEQUENCE_ID
416             + "=/^(?:Label:)?(?:(?:gi\\|(\\d+))|([^:]+))/=$/nested" };
417     String[] idstrings = new String[] {
418     /*
419      * //"LGUL_human", //"QWIQW_123123", "uniprot|why_do+_12313_foo",
420      * //"123123312", "123123 ABCDE foo", "PFAM:PF23943",
421      */
422     "Label:gi|9234|pdb|102L|A" };
423     // TODO: test the setLabel method.
424     for (int i = 0; i < links.length; i++)
425     {
426       UrlLink ul = new UrlLink(links[i]);
427       if (ul.isValid())
428       {
429         System.out.println("\n\n\n");
430         System.out.println("Link " + i + " " + links[i] + " : "
431                 + ul.toString());
432         System.out.println(" pref : "
433                 + ul.getUrl_prefix()
434                 + "\n suf : "
435                 + ul.getUrl_suffix()
436                 + "\n : "
437                 + ((ul.getRegexReplace() != null) ? ul.getRegexReplace()
438                         : ""));
439         for (int ids = 0; ids < idstrings.length; ids++)
440         {
441           System.out.println("ID String : " + idstrings[ids]
442                   + "\nWithout onlyIfMatches:");
443           String[] urls = ul.makeUrls(idstrings[ids], false);
444           testUrls(ul, idstrings[ids], urls);
445           System.out.println("With onlyIfMatches set.");
446           urls = ul.makeUrls(idstrings[ids], true);
447           testUrls(ul, idstrings[ids], urls);
448         }
449       }
450       else
451       {
452         System.err.println("Invalid URLLink : " + links[i] + " : "
453                 + ul.getInvalidMessage());
454       }
455     }
456   }
457
458   public boolean isDynamic()
459   {
460     // TODO Auto-generated method stub
461     return dynamic;
462   }
463
464   public boolean usesSeqId()
465   {
466     return uses_seq_id;
467   }
468
469   public void setLabel(String newlabel)
470   {
471     this.label = newlabel;
472   }
473 }