source: trunk/greenstone3-extensions/gs3build/src/org/greenstone/gsdl3/gs3build/util/URLString.java@ 12188

package org.greenstone.gsdl3.gs3build.util;

import java.applet.*;
import java.net.*;

public class URLString
{ private String url;

  private String urlbase(String url)
  { int index;
    String tailString, bodyString;
    int body;

    index = url.indexOf("//");
    tailString = url.substring(index+2, url.length());
    
    body = tailString.indexOf('/');
    bodyString = tailString.substring(0, body+1);
    
    tailString = url.substring(0, index+2) + bodyString;
    return tailString;
  }
  
  public URLString(String s)
  { this.url = s;
  }

  public URLString(String s, String target)
  { // reconcile
    int sref;
    int cref;
    int c;

    // trim fragment identifiers
    target = noRef(target);
    if (target == null)
    { this.url = s;
      return;
    }

    // test for absolute
    cref = target.indexOf(':');
    if (cref >= 0)
    { for (c = 0; c < cref; c ++)
      { if (target.charAt(c) != '+' &&
        target.charAt(c) != '-' &&
        target.charAt(c) != '.' &&
        Character.isLetterOrDigit(target.charAt(c)) == false)
    { break;
    }
      }
    }
    else
    { c = 0;
    }

    if (c == cref)
    { // absolute reference
      String tmp;

      tmp = target.substring(0, c);
      tmp = tmp.toLowerCase();
      if (target.indexOf("//") == cref + 1)
      { if (target.lastIndexOf('/') == cref + 2)
    { target = target + "/";
    }
      }
      /*            if (tmp.equals("http") == false)
                { this.url = null;
                return;
                }*/
      this.url = target;
    }
    else if (target.indexOf("//") == 0)
    { // absolute - implicit scheme (ie http).; also check for no trailing '/'
      if (target.lastIndexOf('/') == 1)
      { target = target + "/";
      }
      target = "http:" + target;
      this.url = target;
    }
    else
    { // relative - trim silly '/' at end
      if (target.charAt(0) == '/')  
      { // if we get a leading '/' then add it to the base of the url
    s = urlbase(s);
    target = target.substring(1);
    this.url = s + target;
//              System.out.println(this.url+"<"+s+"<"+target);
    return;
      }

      while(target.length() >= 2 && target.charAt(0) == '.' && target.charAt(1) == '.')
      { // move up a level on the left
    
    sref = s.lastIndexOf('/');
    s = s.substring(0, sref);

    target = target.substring(3);
      }
      // strip trailing leaf from s
      sref = s.lastIndexOf('/');
      s = s.substring(0, sref+1);
      // append s+target
      this.url = s + target;
    }
    
    // abandon the url if it is a call to a script
    if (this.url.indexOf('?') >= 0)
    { this.url = null;
    }
  }

  public static boolean dirParent(String parent, String child)
  { while (child.length() >= parent.length())
    { child = child.substring(0, child.lastIndexOf('/'));

      if (parent.equals(child))
      { return true;
      }
    }
    return false;
  }

  public static int dirPos(String from, String to)
  { String fromdir;
    String todir;

    fromdir = from.substring(0, from.lastIndexOf('/'));
    todir   = to.substring(0, to.lastIndexOf('/'));

    if (fromdir.equals(todir))
    { return 0;
    }
    if (fromdir.length() > todir.length())
    { if (dirParent(todir, fromdir) == true)
      { return -1;
      }
    }
    else 
    { if (dirParent(fromdir, todir) == true)
      { return 1;
      }
    }
    return -2;
  }

  public static int commonLevels(String a, String b)
  { String  path_a, path_b;
    int         offset_a, offset_b;
    String  dir_a, dir_b;
    int         common;

    path_a  = path(a);
    path_b  = path(b);
    common  = 0;

    if (path_a == null || path_b == null)
    { return 0;
    }

    do
    { offset_a = path_a.indexOf('/');
      offset_b = path_b.indexOf('/');

      if (offset_a > 0)
      { dir_a       =   path_a.substring(0, offset_a);
        if (path_a.length() > offset_a + 1)
    {   path_a  = path_a.substring(offset_a+1);
    }
    else
    {   path_a  = null;
    }
      }
      else
      { dir_a       =   path_a;
        path_a  = null;
      }

      if (offset_b > 0)
      { dir_b       =   path_b.substring(0, offset_b);
        if (path_b.length() > offset_b + 1)
    {   path_b  = path_b.substring(offset_b+1);
    }
    else
    {   path_b  = null;
    }
      }
      else
      { dir_b       =   path_b;
        path_b  = null;
      }

      if (dir_a.length() != dir_b.length() ||
      dir_a.equals(dir_b) == false)
      { return common;
      }
      common ++;
    } while (path_a != null && path_b != null);
    
    return common;
  }

    public static String dirLevelName(String url, int level)
    {   String  lpath;
        String  dir;
        int         thislevel = 0;
        int         offset;

        lpath = path(url);
        if (lpath == null)
        { return null;
        }
        do
        { offset = lpath.indexOf('/');

            if (offset >= 0)
            {   dir = lpath.substring(0, offset);
                lpath = lpath.substring(offset+1);
            }
            else
            {   dir = lpath;
            }

            thislevel ++;

            if (level == thislevel)
            { return dir;
            }
        } while (offset >= 0);

        return null;
    }

    public static int dirLevel(String url)
    {   String  lpath;
        int         level;
        int         offset;

        lpath = path(url);
        if (lpath == null)
        {   return 0;
        }
        level = 0;
        do
        { offset = lpath.indexOf('/');
            if (offset >= 0)
            {   lpath = lpath.substring(offset+1);
            }
            level ++;
        } while (offset >= 0);

        return level;
    }

    public static String tidyURL(String urlString, boolean permitScript)
    {   int cref;
        int c;
        int sref;
        String tmp, s;

        s = urlString;
        cref = s.indexOf(':');
        if (cref >= 0)
        { for (c = 0; c < cref; c ++)
            { if (s.charAt(c) != '+' &&
                        s.charAt(c) != '-' &&
                        s.charAt(c) != '.' &&
                        Character.isLetterOrDigit(s.charAt(c)) == false)
                { break;
                }
            }
        }
        else
        { c = 0;
        }

        if (cref == c)
        { tmp = s.substring(0, c).toLowerCase();
            s = tmp + s.substring(c, s.length());
            if (s.lastIndexOf('/') == cref + 2)
            { s = s + "/";
            }
        }
        else
        { sref = s.indexOf("//");
            if (sref == 0)
            { s = "http:" + s;
            }
            else
            { s = "http://" + s;
            }
            if (s.lastIndexOf('/') == 6)
            { s = s + "/";
            }
        }
        return s;
    }

    public static String tidyURL(String urlString)
    {   return tidyURL(urlString, false);
    }

    public static URL toURL(String urlString)
    { URL reply;

      try
        { reply = new URL(URLString.tidyURL(urlString));
        }
        catch (MalformedURLException ex)
        { return null;
        }
        return reply;
    }

  public void tidy()
  { this.url = tidyURL(this.url);
  }

  public boolean isNull()
  { if (this.url == null)
    { return true;
    } 
    return false;
  }

  public static boolean isForeign(String home, URL url)
  { if (url.toString().length() < home.length())
    { return true;
    }

    if (home.equals(url.toString().substring(0, home.length())))
    { return false;
    }
    return true;
  }
  
  /**
   *    Remove any trailing "#localanchor" local reference from a URL string
   *
   *  @param  <code>String</code> the original url
   *  @return <code>String</code> the cleaned url, sans local references
   */
  public static String noRef(String target)
  { if (target == null)
    { return null;
    }
    if (target.indexOf('#') >= 0)
    { if (target.indexOf('#') == 0)
      { return null;
      }
      target = target.substring(0, target.indexOf('#'));
    }
    return target;
  }

  /**
   *    Obtain the trailing local anchor reference from a URL, 
   *  if it exists.
   *    e.g. for http://www.test.mdx.ac.uk/example/index.html#credits the
   *         response would be "credits"
   *
   *  @param  <code>String</code> the original url.
   *  @return <code>String</code> the local reference.  <code>null</code> is
   *                              returned if no local reference exists.
   */
  public static String subRef(String target)
  { if (target.indexOf('#') >= 0)
    {   return target.substring(target.indexOf('#')+1);
    }
    return null;
  }

  /**
   *    Clean a URL of the form GET parameters.
   *
   *  @param  <code>String</code> the original url, with GET message parameters
   *  @return <code>String</code> the cleaned url.
   */
  public static String noParameters(String url)
  { int                     c;

    c = url.indexOf("?");
    if (c < 0)
    { return url;
    }
    return url.substring(0, c);
  }

    /**
     *  Obtain the form parameters from a url
     *
     *  @param  <code>String</code> the original url, with GET message parameters
     *  @return <code>String</code> the form "GET" parameters.  The leading '?' is
     *                              preserved in the reply.  If no parameters were
     *                              given, the result is <code>null</code>.
     */
    public static String formParameters(String url)
    {   int                     c;

        c = url.indexOf("?");
        if (c < 0)
        {   return null;
        }
        return url.substring(c);
    }

    /**
     *  Flatten a URL, making the '?' and '&' items into underscores
     *
     *  @param  <code>String</code> the original url, with GET message parameters
     *  @return <code>String</code> the "flattened" url
     */
    public static String flattenedUrl(String oldUrl)
    {   StringBuffer    reply;
        int                     c;
        boolean             modified = false;

        // replace ? with _
        // replate & with _
        reply = new StringBuffer(oldUrl);
        for (c = 0; c < reply.length(); c ++)
        {   if (reply.charAt(c) == '?' ||
                    reply.charAt(c) == '&')
            {   reply.setCharAt(c, '_');
                modified = true;
            }
        }

        if (modified == true)
        {   c   = oldUrl.indexOf(".html");
            if (c >= 0)
            {   while (c < oldUrl.length() - 5)
                {   reply.setCharAt(c, reply.charAt(c+5));
                    c ++;
                }
                reply.setCharAt(c ++, '.');
                reply.setCharAt(c ++, 'h');
                reply.setCharAt(c ++, 't');
                reply.setCharAt(c ++, 'm');
                reply.setCharAt(c ++, 'l');
            }
        }

        return reply.toString();
    }

    /**
     *  Provide the complete pathname in the given url
     *    eg. "example/index.html" for http://www.test.mdx.ac.uk/example/index.html
     *
     *  @param  <code>String</code> url of page
     *  @return <code>String</code> leaf file name
     */
    public static String pathName(String url)
    {   int offset;
        String remainder;

        if (url == null)
        { return null;
        }

        offset = url.indexOf("//");
        if (offset < 0)
        { return null;
        }

        remainder = url.substring(offset + 2);
        offset = remainder.indexOf('/');
        if (offset < 0)
        {   return null;
        }
        return remainder.substring(offset + 1);
    }

    /**
     *  Provide the leaf filename in the given url
     *    eg. "index.html" for http://www.test.mdx.ac.uk/example/index.html
     *
     *  @param  <code>String</code> url of page
     *  @return <code>String</code> leaf file name
     */
    public static String leafName(String url)
    {   int offset;
        int dot;

        if (url == null)
        {   return null;
        }
        offset = url.lastIndexOf('/');
        if (offset < 0)
        { return null;
        }
        if (offset == url.length() - 1)
        { return null;
        }
        dot = url.lastIndexOf('/');
        if (dot < offset)
        {   return null;
        }
        return url.substring(offset+1);
    }

    /**
     *  Provide the hostname in the given url
     *    eg. "www.test.mdx.ac.uk" for http://www.test.mdx.ac.uk/example/index.html
     *
     *  @param  <code>String</code> url of page
     *  @return <code>String</code> host name
     */
    public static String host(String url)
    {   String scheme, tail;
        int      spos;

        spos = url.indexOf("//");
        if (spos >= 0)
        { scheme = url.substring(0, spos + 2);
            tail = url.substring(spos + 2, url.length());
            // do sub-areas
            spos = tail.indexOf('/');
            if (spos >= 0)
            { tail = tail.substring(0, spos+1);
            }
            scheme = scheme + tail;
            return scheme;
        }
        return null;
    }

    /**
     *  Return the logical path of the url on the remote server
     *    eg. "example" for http://www.test.mdx.ac.uk/example/index.html
     *
     *  @param  <code>String</code> url of page
     *  @return <code>String</code> logical path
     */
    public static String path(String url)
    { String tail;
        int offset;
        String leaf;

        if (url == null)
        { return null;
        }

        offset  = url.indexOf("//");
        if (offset < 0)
        {   return null;
        }

        tail        = url.substring(offset+2);
        offset  = tail.indexOf('/');
        if (offset < 0)
        {   return null;
        }

        tail        = tail.substring(offset+1);
        if (tail == null || tail.length() == 0)
        {   return null;
        }

        offset  = tail.lastIndexOf('/');
        if (offset < 0)
        { return null;
        }
        else
        {   tail = tail.substring(0, offset);
        }
        return tail;
    }

    /**
     *  Give the 'dot' extension of a url; 
     *    eg. "html" for http://www.test.mdx.ac.uk/example/index.html
     *
     *  @param <code>String</code> url
     *  @return <code>String</code> extension.
     */
    public static String extension(String url)
    { int offset;
        String leaf;

        if (url == null)
        { return null;
        }

        offset = url.lastIndexOf('/');
        if (offset >= 0 && offset < url.length() - 1)
        { leaf = url.substring(offset+1, url.length());
            offset = leaf.lastIndexOf('.');

            // if we've got an extension then use it
            if (offset >= 0)
            { int poffset;

                // get parameter offset
                poffset = leaf.indexOf('?');
                if (poffset < 0)
                {   poffset = leaf.length();
                }

                // give leaf value
                return leaf.substring(offset, poffset);
            }
            else
            { return null;
            }
        }
        return null;
    }

  public static String extension(URL url)
  { return extension(url.toString());
  }

  public String toString()
  { return this.url;
  }
}