Esempio n. 1
0
  /**
   * Returns results from parsing a {@link java.net.URI} with this pattern. If the URI doesn't match
   * the pattern, this will return null.
   *
   * @param uri A URI to match against this URIPattern
   * @return A Map of the pattern's variable names to values from the parsed URI
   */
  public Map<String, String> getMatch(URI uri) {
    // verify that the schemes match
    if (pattern.isAbsolute()) {
      // if there should be a scheme, make sure it matches
      if (!pattern.getScheme().equalsIgnoreCase(uri.getScheme())) {
        return null;
      }
    } else if (uri.getScheme() != null) {
      return null;
    }

    Map<String, String> result = Maps.newLinkedHashMap(defaults);

    if (pattern.isOpaque()) {
      if (!uri.isOpaque()) {
        return null;
      }

      Iterator<String> pathQuery =
          PATH_QUERY_SPLITTER.split(uri.getRawSchemeSpecificPart()).iterator();

      if (!addPath(patternPath, Iterators.getNext(pathQuery, null), result)) {
        return null;
      }

      addQuery(Iterators.getNext(pathQuery, null), result);

    } else if (!uri.isOpaque()) {
      addAuthority(uri, result);

      if (patternPath.isEmpty() && !uri.getRawPath().isEmpty()) {
        return null;
      }

      if (!addPath(patternPath, uri.getRawPath(), result)) {
        return null;
      }

      addQuery(uri.getRawQuery(), result);

    } else {
      return null;
    }

    if (!addComplexMatch(pattern.getFragment(), uri.getFragment(), result)) {
      return null;
    }

    // save this match
    this.lastMatch = result;

    // return the new result, so that this is thread-safe
    return result;
  }
Esempio n. 2
0
  @Override
  public Path resolve(Path path) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    if (cl != null) {
      String spath = path.toString();
      String substituted = FILE_SEP == '/' ? spath : spath.replace(FILE_SEP, '/');
      URL url = cl.getResource(substituted);
      if (url != null) {
        if (FILE_SEP == '/') {
          // *nix - a bit quicker than pissing around with URIs
          String sfile = url.getFile();
          if (sfile != null) {
            return Paths.get(url.getFile());
          }
        } else {
          // E.g. windows
          // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4701321

          try {
            URI uri = url.toURI();
            if (uri.isOpaque()) {
              return Paths.get(url.getPath());
            } else {
              return Paths.get(uri);
            }
          } catch (Exception exc) {
            throw new VertxException(exc);
          }
        }
      }
    }
    return path;
  }
Esempio n. 3
0
 /**
  * Compares the URI with the given object for equality. If the object is not a <code>URI</code>,
  * then the method returns false. Otherwise, the following criteria are observed:
  *
  * <ul>
  *   <li>The scheme of the URIs must either be null (undefined) in both cases, or equal, ignorant
  *       of case.
  *   <li>The raw fragment of the URIs must either be null (undefined) in both cases, or equal,
  *       ignorant of case.
  *   <li>Both URIs must be of the same type (opaque or hierarchial)
  *   <li><strong>For opaque URIs:</strong>
  *       <ul>
  *         <li>The raw scheme-specific parts must be equal.
  *       </ul>
  *   <li>For hierarchical URIs:
  *       <ul>
  *         <li>The raw paths must be equal, ignorant of case.
  *         <li>The raw queries are either both undefined or both equal, ignorant of case.
  *         <li>The raw authority sections are either both undefined or:
  *         <li><strong>For registry-based authorities:</strong>
  *             <ul>
  *               <li>they are equal.
  *             </ul>
  *         <li><strong>For server-based authorities:</strong>
  *             <ul>
  *               <li>the hosts are equal, ignoring case
  *               <li>the ports are equal
  *               <li>the user information components are equal
  *             </ul>
  *       </ul>
  * </ul>
  *
  * @param obj the obj to compare the URI with.
  * @return <code>true</code> if the objects are equal, according to the specification above.
  */
 public boolean equals(Object obj) {
   if (!(obj instanceof URI)) return false;
   URI uriObj = (URI) obj;
   if (scheme == null) {
     if (uriObj.getScheme() != null) return false;
   } else if (!(scheme.equalsIgnoreCase(uriObj.getScheme()))) return false;
   if (rawFragment == null) {
     if (uriObj.getRawFragment() != null) return false;
   } else if (!(rawFragment.equalsIgnoreCase(uriObj.getRawFragment()))) return false;
   boolean opaqueThis = isOpaque();
   boolean opaqueObj = uriObj.isOpaque();
   if (opaqueThis && opaqueObj)
     return rawSchemeSpecificPart.equals(uriObj.getRawSchemeSpecificPart());
   else if (!opaqueThis && !opaqueObj) {
     boolean common =
         rawPath.equalsIgnoreCase(uriObj.getRawPath())
             && ((rawQuery == null && uriObj.getRawQuery() == null)
                 || rawQuery.equalsIgnoreCase(uriObj.getRawQuery()));
     if (rawAuthority == null && uriObj.getRawAuthority() == null) return common;
     if (host == null) return common && rawAuthority.equalsIgnoreCase(uriObj.getRawAuthority());
     return common
         && host.equalsIgnoreCase(uriObj.getHost())
         && port == uriObj.getPort()
         && (rawUserInfo == null
             ? uriObj.getRawUserInfo() == null
             : rawUserInfo.equalsIgnoreCase(uriObj.getRawUserInfo()));
   } else return false;
 }
  private String parseURI(URI uri) {
    if (!uri.isAbsolute()) {
      throw new IllegalArgumentException(uri + " is not an absolute URI");
    }

    return uri.isOpaque() ? parseOpaqueURI(uri) : parseHierarchicalURI(uri);
  }
  @Override
  public UriBuilder uri(URI uri) {
    if (uri == null) {
      throw new IllegalArgumentException("URI parameter is null");
    }

    if (uri.getRawFragment() != null) {
      fragment = uri.getRawFragment();
    }

    if (uri.isOpaque()) {
      scheme = uri.getScheme();
      ssp = uri.getRawSchemeSpecificPart();
      return this;
    }

    if (uri.getScheme() == null) {
      if (ssp != null) {
        if (uri.getRawSchemeSpecificPart() != null) {
          ssp = uri.getRawSchemeSpecificPart();
          return this;
        }
      }
    } else {
      scheme = uri.getScheme();
    }

    ssp = null;
    if (uri.getRawAuthority() != null) {
      if (uri.getRawUserInfo() == null && uri.getHost() == null && uri.getPort() == -1) {
        authority = uri.getRawAuthority();
        userInfo = null;
        host = null;
        port = -1;
      } else {
        authority = null;
        if (uri.getRawUserInfo() != null) {
          userInfo = uri.getRawUserInfo();
        }
        if (uri.getHost() != null) {
          host = uri.getHost();
        }
        if (uri.getPort() != -1) {
          port = uri.getPort();
        }
      }
    }

    if (uri.getRawPath() != null && uri.getRawPath().length() > 0) {
      path.setLength(0);
      path.append(uri.getRawPath());
    }
    if (uri.getRawQuery() != null && uri.getRawQuery().length() > 0) {
      query.setLength(0);
      query.append(uri.getRawQuery());
    }

    return this;
  }
 /** Convert a java.net.URI to a Uri. */
 public static Uri fromJavaUri(URI uri) {
   if (uri.isOpaque()) {
     throw new IllegalArgumentException("No support for opaque Uris " + uri.toString());
   }
   return new UriBuilder()
       .setScheme(uri.getScheme())
       .setAuthority(uri.getRawAuthority())
       .setPath(uri.getRawPath())
       .setQuery(uri.getRawQuery())
       .setFragment(uri.getRawFragment())
       .toUri();
 }
  /**
   * creates a canonical representation of the uriString. This method performs certain translations
   * depending on the type of URI generated by the string.
   */
  private URI canonicalize(String uriString) throws URISyntaxException {
    if ((uriString == null) || (uriString.compareTo("localhost") == 0)) {
      uriString = "//localhost";
      return new URI(uriString);
    }

    URI u = new URI(uriString);

    if (u.isAbsolute()) {
      if (u.isOpaque()) {
        /*
         * this code is here to deal with a special case. For ease of use, we'd like to be able to handle the case where the user specifies hostname:port, not requiring the scheme part. This introduces some subtleties. hostname:port - scheme = hostname - schemespecificpart = port - hostname = null - userinfo=null however, someone could also enter scheme:hostname:port and get into this code. the strategy is to consider this syntax illegal and provide some code to defend against it.
         * Basically, we test that the string contains only one ":" and that the ssp is numeric. If we get two colons, we will attempt to insert the "//" after the first colon and then try to create a URI from the resulting string.
         */
        String scheme = u.getScheme();
        String ssp = u.getSchemeSpecificPart();
        String frag = u.getFragment();
        URI u2 = null;

        int c1index = uriString.indexOf(":");
        int c2index = uriString.lastIndexOf(":");
        if (c2index != c1index) {
          /*
           * this is the scheme:hostname:port case. Attempt to transform this to scheme://hostname:port. If a path part is part of the original strings, it will be included in the SchemeSpecificPart. however, the fragment part must be handled separately.
           */
          if (frag == null) {
            u2 = new URI(scheme + "://" + ssp);
          } else {
            u2 = new URI(scheme + "://" + ssp + "#" + frag);
          }
          return u2;
        }
        /*
         * here we have the <string>:<string> case, possibly with optional path and fragment components. we assume that the part following the colon is a number. we don't check this condition here as it will get detected later anyway.
         */
        u2 = new URI("//" + uriString);
        return u2;
      } else {
        return u;
      }
    } else {
      /*
       * This is the case where we were given a hostname followed by a path part, fragment part, or both a path and fragment part. The key here is that no scheme part was specified. For this case, if the scheme specific part does not begin with "//", then we prefix the "//" to the given string and attempt to create a URI from the resulting string.
       */
      String ssp = u.getSchemeSpecificPart();
      if (ssp.startsWith("//")) {
        return u;
      } else {
        return new URI("//" + uriString);
      }
    }
  }
Esempio n. 8
0
 private static File resourceAsFile(String path) throws URISyntaxException, IOException {
   ClassLoader cl = TestUtils.class.getClassLoader();
   URI uri = cl.getResource(path).toURI();
   if (uri.isAbsolute() && !uri.isOpaque()) {
     return new File(uri);
   } else {
     File tmpFile = File.createTempFile("tmpfile-", ".data", TMP_DIR);
     tmpFile.deleteOnExit();
     try (InputStream is = cl.getResourceAsStream(path)) {
       FileUtils.copyInputStreamToFile(is, tmpFile);
       return tmpFile;
     }
   }
 }
Esempio n. 9
0
  /**
   * Constructs a {@link URI} that matches this pattern from the given options.
   *
   * @param options a map of variable and
   * @return a {@link URI} that matches this pattern
   * @throws IllegalArgumentException if the URI cannot be constructed
   */
  public URI construct(Map<String, String> options) {
    // make a copy that can be modified
    Map<String, String> uriData = Maps.newLinkedHashMap(options);
    try {
      // scheme should always be present, but default if necessary
      String scheme = defaults.get(SCHEME);
      if (uriData.containsKey(SCHEME)) {
        scheme = uriData.remove(SCHEME);
      }

      StringBuilder builder = new StringBuilder();
      builder.append(scheme).append(":");

      if (!pattern.isOpaque()) {
        // Build the URI(String,String,String,int,String,String,String)
        StringBuilder authBuilder = new StringBuilder();
        String user = constructUserInfo(uriData, defaults);
        String host = removeNonDefault(HOST, uriData, defaults);
        int port = constructPort(uriData, defaults);
        if (user != null) {
          authBuilder.append(user).append("@");
        }
        if (host != null) {
          authBuilder.append(host);
        }
        if (port >= 0) {
          authBuilder.append(":").append(port);
        }
        String auth = authBuilder.toString();
        if (!auth.isEmpty()) {
          builder.append("//").append(auth);
        }
      }

      builder.append(constructPath(uriData, patternPath));

      String query = constructQuery(uriData, defaults);
      if (query != null) {
        builder.append("?").append(query);
      }

      return new URI(builder.toString());

    } catch (URISyntaxException ex) {
      throw new IllegalArgumentException("Could not build URI", ex);
    }
  }
  /**
   * Returns the path from the given {@link URI}. In case the given {@link URI} is opaque, e.g.
   * beginning with jar:file, the path is extracted from URI by leaving out the protocol prefix.
   *
   * @param uri
   * @return
   * @see DATAJPA-519
   */
  private static String getResourcePath(URI uri) throws IOException {

    if (uri.isOpaque()) {
      // e.g. jar:file:/foo/lib/somelib.jar!/com/acme/orm.xml
      String rawPath = uri.toString();
      if (rawPath != null) {
        int exclamationMarkIndex = rawPath.lastIndexOf('!');
        if (exclamationMarkIndex > -1) {

          // /com/acme/orm.xml
          return rawPath.substring(exclamationMarkIndex + 1);
        }
      }
    }

    return uri.getPath();
  }
Esempio n. 11
0
 public AttachmentPart getAttachment(java.net.URI ref, Iterator iter) {
   if (iter == null || ref == null) {
     System.err.println("getAttachment: null Iterator for AttachmentPart");
     return null;
   }
   while (iter.hasNext()) {
     AttachmentPart tempAttachment = (AttachmentPart) iter.next();
     if (ref.isOpaque() && ref.getScheme().equals("cid")) {
       String refId = ref.getSchemeSpecificPart();
       String cId = tempAttachment.getContentId();
       if (cId.equals("<" + refId + ">") || cId.equals(refId)) {
         return tempAttachment;
       }
     }
   }
   return null;
 }
Esempio n. 12
0
 /**
  * Determines the protocol element to be used to access the specified uri.
  *
  * @param uri source reference
  * @return protocol element or null if no one can handle this
  */
 static YurconfProtocol forUri(final URI uri) {
   if (uri.isAbsolute() && SCHEME.equals(uri.getScheme())) {
     if (uri.isOpaque()) {
       return REPOSITORY_SOURCE;
     } else {
       final String authority = uri.getAuthority();
       if (authority == null) {
         return REPOSITORY_SOURCE;
       } else {
         if (authority.startsWith(PROCESSOR_RESOURCE.AT)) {
           return PROCESSOR_RESOURCE;
         } else {
           return REPOSITORY_SOURCE;
         }
       }
     }
   }
   return null;
 }
Esempio n. 13
0
 /**
  * Relativizes the given URI against this URI. The following algorithm is used:
  *
  * <ul>
  *   <li>If either URI is opaque, the given URI is returned.
  *   <li>If the schemes of the URIs differ, the given URI is returned.
  *   <li>If the authority components of the URIs differ, then the given URI is returned.
  *   <li>If the path of this URI is not a prefix of the supplied URI, then the given URI is
  *       returned.
  *   <li>If all the above conditions hold, a new URI is created using the query and fragment
  *       components of the given URI, along with a path computed by removing the path of this URI
  *       from the start of the path of the supplied URI.
  * </ul>
  *
  * @param uri the URI to relativize agsint this URI
  * @return the resulting URI
  * @throws NullPointerException if the uri is null
  */
 public URI relativize(URI uri) {
   if (isOpaque() || uri.isOpaque()) return uri;
   if (scheme == null && uri.getScheme() != null) return uri;
   if (scheme != null && !(scheme.equals(uri.getScheme()))) return uri;
   if (rawAuthority == null && uri.getRawAuthority() != null) return uri;
   if (rawAuthority != null && !(rawAuthority.equals(uri.getRawAuthority()))) return uri;
   if (!(uri.getRawPath().startsWith(rawPath))) return uri;
   try {
     return new URI(
         null,
         null,
         uri.getRawPath().substring(rawPath.length()),
         uri.getRawQuery(),
         uri.getRawFragment());
   } catch (URISyntaxException e) {
     throw (Error)
         new InternalError("Relativized URI variant could not " + "be constructed").initCause(e);
   }
 }
Esempio n. 14
0
  public URIPattern(URI uri) {
    this.pattern = uri;

    Map<String, String> accumulator = Maps.newHashMap();
    if (pattern.isOpaque()) {
      Iterator<String> pathQuery =
          PATH_QUERY_SPLITTER.split(pattern.getSchemeSpecificPart()).iterator();
      this.patternPath = Iterators.getNext(pathQuery, null);
      addQuery(Iterators.getNext(pathQuery, null), accumulator);
    } else {
      patternPath = pattern.getRawPath();
      addQuery(pattern.getRawQuery(), accumulator);
      addAuthority(pattern, accumulator);
    }
    if (pattern.getScheme() != null) {
      accumulator.put(SCHEME, pattern.getScheme());
    }
    this.defaults = ImmutableMap.copyOf(accumulator);
  }
Esempio n. 15
0
 /**
  * Compare the URI with another object that must also be a URI. Undefined components are taken to
  * be less than any other component. The following criteria are observed:
  *
  * <ul>
  *   <li>Two URIs with different schemes are compared according to their scheme, regardless of
  *       case.
  *   <li>A hierarchical URI is less than an opaque URI with the same scheme.
  *   <li><strong>For opaque URIs:</strong>
  *       <ul>
  *         <li>URIs with differing scheme-specific parts are ordered according to the ordering of
  *             the scheme-specific part.
  *         <li>URIs with the same scheme-specific part are ordered by the raw fragment.
  *       </ul>
  *   <li>For hierarchical URIs:
  *       <ul>
  *         <li>URIs are ordered according to their raw authority sections, if they are unequal.
  *         <li><strong>For registry-based authorities:</strong>
  *             <ul>
  *               <li>they are ordered according to the ordering of the authority component.
  *             </ul>
  *         <li><strong>For server-based authorities:</strong>
  *             <ul>
  *               <li>URIs are ordered according to the raw user information.
  *               <li>URIs with the same user information are ordered by the host, ignoring case.
  *               <lI>URIs with the same host are ordered by the port.
  *             </ul>
  *         <li>URIs with the same authority section are ordered by the raw path.
  *         <li>URIs with the same path are ordered by their raw query.
  *         <li>URIs with the same query are ordered by their raw fragments.
  *       </ul>
  * </ul>
  *
  * @param obj This object to compare this URI with
  * @return a negative integer, zero or a positive integer depending on whether this URI is less
  *     than, equal to or greater than that supplied, respectively.
  * @throws ClassCastException if the given object is not a URI
  */
 public int compareTo(Object obj) throws ClassCastException {
   URI uri = (URI) obj;
   if (scheme == null && uri.getScheme() != null) return -1;
   if (scheme != null) {
     int sCompare = scheme.compareToIgnoreCase(uri.getScheme());
     if (sCompare != 0) return sCompare;
   }
   boolean opaqueThis = isOpaque();
   boolean opaqueObj = uri.isOpaque();
   if (opaqueThis && !opaqueObj) return 1;
   if (!opaqueThis && opaqueObj) return -1;
   if (opaqueThis) {
     int ssCompare = rawSchemeSpecificPart.compareTo(uri.getRawSchemeSpecificPart());
     if (ssCompare == 0) return compareFragments(uri);
     else return ssCompare;
   }
   if (rawAuthority == null && uri.getRawAuthority() != null) return -1;
   if (rawAuthority != null) {
     int aCompare = rawAuthority.compareTo(uri.getRawAuthority());
     if (aCompare != 0) {
       if (host == null) return aCompare;
       if (rawUserInfo == null && uri.getRawUserInfo() != null) return -1;
       int uCompare = rawUserInfo.compareTo(uri.getRawUserInfo());
       if (uCompare != 0) return uCompare;
       if (host == null && uri.getHost() != null) return -1;
       int hCompare = host.compareTo(uri.getHost());
       if (hCompare != 0) return hCompare;
       return new Integer(port).compareTo(new Integer(uri.getPort()));
     }
   }
   if (rawPath == null && uri.getRawPath() != null) return -1;
   if (rawPath != null) {
     int pCompare = rawPath.compareTo(uri.getRawPath());
     if (pCompare != 0) return pCompare;
   }
   if (rawQuery == null && uri.getRawQuery() != null) return -1;
   if (rawQuery != null) {
     int qCompare = rawQuery.compareTo(uri.getRawQuery());
     if (qCompare != 0) return qCompare;
   }
   return compareFragments(uri);
 }
Esempio n. 16
0
 private File getRepositoryFile(final URI uri, final AbstractProcessor processor) {
   if (uri.isOpaque()) {
     final String path = uri.getSchemeSpecificPart();
     if (path.startsWith("/")) {
       final File repoRoot = processor.getFactory().getRepository().getRoot();
       return new File(repoRoot, path.substring(1));
     } else {
       final File productRepo =
           processor
               .getFactory()
               .getRepository()
               .getProductDirectory(processor.getDescriptor().getProductId());
       return new File(productRepo, path);
     }
   } else {
     final String productId =
         uri.getHost() == null ? processor.getDescriptor().getProductId() : uri.getHost();
     return new File(
         processor.getFactory().getRepository().getProductDirectory(productId),
         uri.getPath().substring(1));
   }
 }
Esempio n. 17
0
  /**
   * Resolves the given URI against this URI
   *
   * @param uri The URI to resolve against this URI
   * @return The resulting URI, or null when it couldn't be resolved for some reason.
   * @throws NullPointerException if uri is null
   */
  public URI resolve(URI uri) {
    if (uri.isAbsolute()) return uri;
    if (uri.isOpaque()) return uri;

    String scheme = uri.getScheme();
    String schemeSpecificPart = uri.getSchemeSpecificPart();
    String authority = uri.getAuthority();
    String path = uri.getPath();
    String query = uri.getQuery();
    String fragment = uri.getFragment();

    try {
      if (fragment != null
          && path != null
          && path.equals("")
          && scheme == null
          && authority == null
          && query == null) return new URI(this.scheme, this.schemeSpecificPart, fragment);

      if (authority == null) {
        authority = this.authority;
        if (path == null) path = "";
        if (!(path.startsWith("/"))) {
          StringBuilder basepath = new StringBuilder(this.path);
          int i = this.path.lastIndexOf('/');

          if (i >= 0) basepath.delete(i + 1, basepath.length());

          basepath.append(path);
          path = normalizePath(basepath.toString());
        }
      }
      return new URI(this.scheme, authority, path, query, fragment);
    } catch (URISyntaxException e) {
      throw (Error)
          new InternalError("Resolved URI variant could not " + "be constructed").initCause(e);
    }
  }