Add new resource utils functions

Author: Artem Labazin

CHANGELOG.md

@@ -12,6 +12,20 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Add more tests.
 - Add `JavaDoc`.
 
+## [1.10.0](https://github.com/appulse-projects/utils-java/releases/tag/1.10.0) - 2018-09-25
+
+### Added
+
+- `FifoCache` implementation;
+- `ResourceUtils.getResourceUrls` function for flexible searching resource files;
+- `ResourceUtils.get*Content` functions for extracting resource files content;
+- A test for checking `ResourceUtils.getResourceUrls` and `ResourceUtils.get*Content` functions.
+
+### Changed
+
+- `ResourceUtils.getResource` are deprecated, use `ResourceUtils.get*Content` functions;
+- `LruCache` and `FifoCache` moved to `io.appulse.utils.cache` package.
+
 ## [1.9.0](https://github.com/appulse-projects/utils-java/releases/tag/1.9.0) - 2018-09-11
 
 ### Added

pom.xml

@@ -24,7 +24,7 @@ limitations under the License.
 
   <groupId>io.appulse</groupId>
   <artifactId>utils-java</artifactId>
-  <version>1.9.0</version>
+  <version>1.10.0</version>
   <packaging>jar</packaging>
 
   <properties>
@@ -62,7 +62,7 @@ limitations under the License.
     <url>https://github.com/appulse-projects/utils-java</url>
     <connection>scm:git:https://github.com/appulse-projects/utils-java.git</connection>
     <developerConnection>scm:git:https://github.com/appulse-projects/utils-java.git</developerConnection>
-    <tag>1.9.0</tag>
+    <tag>1.10.0</tag>
   </scm>
 
   <distributionManagement>

src/main/java/io/appulse/utils/ResourceUtils.java

@@ -20,11 +20,25 @@
 import static java.util.Optional.empty;
 import static java.util.Optional.of;
 
+import java.io.File;
 import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLDecoder;
 import java.nio.charset.Charset;
+import java.util.Enumeration;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
 
 import lombok.NonNull;
+import lombok.SneakyThrows;
 import lombok.val;
 
 /**
@@ -34,11 +48,76 @@
  */
 public final class ResourceUtils {
 
+  @Deprecated
   public static Optional<String> getResource (@NonNull String name) {
     return getResource(name, UTF_8);
   }
 
+  @Deprecated
   public static Optional<String> getResource (@NonNull String name, @NonNull Charset charset) {
+    return getTextContent(name, charset);
+  }
+
+  /**
+   * Returns bytes content of a resource file by its URL.
+   *
+   * @param url adress to a resource.
+   *
+   * @return file's bytes representation, if exists, or empty.
+   *
+   * @since 1.10.0
+   */
+  public static Optional<byte[]> getBytesContent (@NonNull URL url) {
+    try {
+      InputStream inputStream = url.openStream();
+      byte[] bytes = BytesUtils.read(inputStream);
+      return of(bytes);
+    } catch (Exception ex) {
+      return empty();
+    }
+  }
+
+  /**
+   * Returns text content of a resource file by its URL.
+   *
+   * @param url adress to a resource.
+   *
+   * @param charset text content charset.
+   *
+   * @return file's text representation, if exists, or empty.
+   *
+   * @since 1.10.0
+   */
+  public static Optional<String> getTextContent (@NonNull URL url, @NonNull Charset charset) {
+    return getBytesContent(url)
+        .map(it -> new String(it, charset));
+  }
+
+  /**
+   * Returns a concrete resource content by its name.
+   *
+   * @param name file's name
+   *
+   * @return file's text representation, if exists, or empty.
+   *
+   * @since 1.10.0
+   */
+  public static Optional<String> getTextContent (@NonNull String name) {
+    return getTextContent(name, UTF_8);
+  }
+
+  /**
+   * Returns a concrete resource content by its name.
+   *
+   * @param name file's name
+   *
+   * @param charset text content charset.
+   *
+   * @return file's text representation, if exists, or empty.
+   *
+   * @since 1.10.0
+   */
+  public static Optional<String> getTextContent (@NonNull String name, @NonNull Charset charset) {
     val classLoader = Thread.currentThread().getContextClassLoader();
     InputStream inputStream = classLoader.getResourceAsStream(name);
     if (inputStream == null) {
@@ -53,6 +132,127 @@ public static Optional<String> getResource (@NonNull String name, @NonNull Chars
     return of(string);
   }
 
+  /**
+   * Returns text content of a resource file by its URL.
+   *
+   * @param url adress to a resource.
+   *
+   * @return file's text representation, if exists, or empty.
+   *
+   * @since 1.10.0
+   */
+  public static Optional<String> getTextContent (@NonNull URL url) {
+    return getTextContent(url, UTF_8);
+  }
+
+  /**
+   * Searches resource files in specific folder and by glob-pattern.
+   * <p>
+   * It uses glob-like pattern sysytem...honestly speaking only '*' and '?' signs.
+   *
+   * @param folder where to search the files
+   *
+   * @param glob files name glob-pattern
+   *
+   * @return the URLs of found files
+   *
+   * @since 1.10.0
+   */
+  public static List<URL> getResourceUrls (@NonNull String folder, @NonNull String glob) {
+    Pattern pattern = of(glob)
+        .map(Pattern::quote)
+        .map(it -> it.replace("*", "\\E.*\\Q"))
+        .map(it -> it.replace("?", "\\E.\\Q"))
+        .map(it -> '^' + it + '$')
+        .map(Pattern::compile)
+        .orElseThrow(RuntimeException::new);
+
+    return getResourceUrls(folder, pattern);
+  }
+
+  /**
+   * Searches resource files in specific folder and by pattern.
+   *
+   * @param folder where to search the files
+   *
+   * @param pattern files name pattern
+   *
+   * @return the URLs of found files
+   *
+   * @since 1.10.0
+   */
+  @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
+  @SneakyThrows
+  public static List<URL> getResourceUrls (@NonNull String folder, @NonNull Pattern pattern) {
+    List<URL> result = new LinkedList<>();
+
+    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+    Enumeration<URL> urls = classLoader.getResources(folder);
+
+    while (urls.hasMoreElements()) {
+      URL url = urls.nextElement();
+      if (url == null) {
+        continue;
+      }
+
+      switch (url.getProtocol()) {
+      case "file":
+        toFile(url)
+            .map(file -> file.isFile()
+                         ? new File[]{ file }
+                         : file.listFiles()
+            )
+            .filter(Objects::nonNull)
+            .ifPresent(files -> Stream.of(files)
+                .filter(it -> pattern.matcher(it.getName()).matches())
+                .map(it -> {
+                  try {
+                    return it.toURI().toURL();
+                  } catch (Exception ex) {
+                    return null;
+                  }
+                })
+                .filter(Objects::nonNull)
+                .forEach(result::add));
+        break;
+      case "jar":
+        String dirname = of(folder)
+            .filter(it -> it.endsWith("/"))
+            .orElseGet(() -> folder + '/');
+
+        String path = url.getPath();
+        String jarPath = path.substring(5, path.indexOf('!'));
+
+        try (JarFile jar = new JarFile(URLDecoder.decode(jarPath, UTF_8.name()))) {
+          jar.stream()
+              .map(JarEntry::getName)
+              .filter(it -> it.startsWith(dirname))
+              .filter(it -> pattern.matcher(it).matches())
+              .map(it -> classLoader.getResource(it))
+              .forEach(result::add);
+        }
+        break;
+      default:
+        throw new UnsupportedOperationException("unsupported protocol " + url.getProtocol());
+      }
+    }
+
+    return result;
+  }
+
+  private static Optional<File> toFile (URL url) throws URISyntaxException {
+    URI uri = url.toURI();
+    try {
+      return of(new File(uri));
+    } catch (Exception ex1) {
+      try {
+        return of(new File(uri.getPath()));
+      } catch (Exception ex2) {
+        return empty();
+      }
+    }
+  }
+
   private ResourceUtils () {
   }
 }

src/main/java/io/appulse/utils/cache/FifoCache.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appulse.utils.cache;
+
+import static lombok.AccessLevel.PRIVATE;
+
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+
+import lombok.experimental.FieldDefaults;
+
+
+/**
+ * FIFO cache implementation based on {@code LinkedHashMap}.
+ *
+ * @author Artem Labazin
+ * @since 1.10.0
+ */
+@FieldDefaults(level = PRIVATE, makeFinal = true)
+public class FifoCache<K, V> extends LinkedHashMap<K, V> {
+
+  private static final long serialVersionUID = 2326368924657010098L;
+
+  int maxSize;
+
+  public FifoCache (int maxSize) {
+    super(maxSize + 1, 1.0F, false);
+    this.maxSize = maxSize;
+  }
+
+  @Override
+  protected boolean removeEldestEntry (Entry<K, V> eldest) {
+    return size() > maxSize;
+  }
+}

…main/java/io/appulse/utils/LruCache.java …ava/io/appulse/utils/cache/LruCache.javasrc/main/java/io/appulse/utils/LruCache.java renamed to src/main/java/io/appulse/utils/cache/LruCache.java src/main/java/io/appulse/utils/LruCache.java renamed to src/main/java/io/appulse/utils/cache/LruCache.java

@@ -14,22 +14,28 @@
  * limitations under the License.
  */
 
-package io.appulse.utils;
+package io.appulse.utils.cache;
+
+import static lombok.AccessLevel.PRIVATE;
 
 import java.util.LinkedHashMap;
 import java.util.Map.Entry;
 
+import lombok.experimental.FieldDefaults;
+
+
 /**
- * LRU cache implementation based on {@code LinkedHashMap}
+ * LRU cache implementation based on {@code LinkedHashMap}.
  *
  * @author Artem Labazin
  * @since 1.9.0
  */
+@FieldDefaults(level = PRIVATE, makeFinal = true)
 public class LruCache<K, V> extends LinkedHashMap<K, V> {
 
   private static final long serialVersionUID = -1100634446524987320L;
 
-  private final int maxSize;
+  int maxSize;
 
   public LruCache (int maxSize) {
     super(maxSize + 1, 1.0F, true);

src/test/java/io/appulse/utils/ResourceUtilsTest.java

@@ -16,8 +16,12 @@
 
 package io.appulse.utils;
 
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.List;
+import java.util.Optional;
+
 import org.junit.Test;
 
 /**
@@ -39,4 +43,16 @@ public void notExist () {
     assertThat(ResourceUtils.getResource("/not-exist.txt"))
         .isNotPresent();
   }
+
+  @Test
+  public void getResourceUrls () {
+    List<String> list = ResourceUtils.getResourceUrls("folder", "file-?.*")
+        .stream()
+        .map(ResourceUtils::getTextContent)
+        .map(Optional::get)
+        .map(String::trim)
+        .collect(toList());
+
+    assertThat(list).contains("Artem", "Liza", "Milada", "Thais");
+  }
 }

src/test/resources/folder/file-1.txt

@@ -0,0 +1 @@
+Artem

src/test/resources/folder/file-11.txt

@@ -0,0 +1 @@
+popa

src/test/resources/folder/file-2.md

@@ -0,0 +1 @@
+Liza

src/test/resources/folder/file-3.exe

@@ -0,0 +1 @@
+Milada