Skip to content

Commit b6256e8

Browse files
JavaSaBrJavaSaBr
committed
extends API for StringUtils and Enums
1 parent 1d111e6 commit b6256e8

7 files changed

Lines changed: 213 additions & 7 deletions

File tree

‎README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ repositories {
1414
}
1515
1616
ext {
17-
rlibVersion = "10.0.alpha9"
17+
rlibVersion = "10.0.alpha10"
1818
}
1919
2020
dependencies {

‎build.gradle‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
rootProject.version = "10.0.alpha9"
1+
rootProject.version = "10.0.alpha10"
22
group = 'javasabr.rlib'
33

44
allprojects {

‎rlib-common/src/main/java/javasabr/rlib/common/AliasedEnum.java‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
package javasabr.rlib.common;
2+
3+
import java.util.Collection;
4+
5+
public interface AliasedEnum<T extends Enum<T>> {
6+
7+
Collection<String> aliases();
8+
}

‎rlib-common/src/main/java/javasabr/rlib/common/util/AliasedEnumMap.java‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
package javasabr.rlib.common.util;
2+
3+
import java.util.HashMap;
4+
import java.util.Map;
5+
import javasabr.rlib.common.AliasedEnum;
6+
import lombok.AccessLevel;
7+
import lombok.CustomLog;
8+
import lombok.experimental.FieldDefaults;
9+
import org.jspecify.annotations.Nullable;
10+
11+
@CustomLog
12+
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
13+
public class AliasedEnumMap<T extends Enum<T> & AliasedEnum<T>> {
14+
15+
Map<String, T> aliasToValue;
16+
17+
public AliasedEnumMap(Class<T> enumClass) {
18+
var enumConstants = enumClass.getEnumConstants();
19+
var aliasToValue = new HashMap<String, T>();
20+
21+
for (T enumConstant : enumConstants) {
22+
for (String alias : enumConstant.aliases()) {
23+
T previous = aliasToValue.put(alias, enumConstant);
24+
if (previous != null) {
25+
throw new IllegalArgumentException("Detect duplicated alias:[%s] for [%s] and [%s]".formatted(
26+
alias,
27+
previous.name(),
28+
enumConstant.name()));
29+
}
30+
}
31+
}
32+
this.aliasToValue = Map.copyOf(aliasToValue);
33+
}
34+
35+
@Nullable
36+
public T resolve(String alias) {
37+
return aliasToValue.get(alias);
38+
}
39+
40+
public T resolve(String alias, T def) {
41+
T resolved = resolve(alias);
42+
return resolved == null ? def : resolved;
43+
}
44+
45+
public T require(String alias) {
46+
T constant = resolve(alias);
47+
if (constant == null) {
48+
throw new IllegalArgumentException("Unknown enum constant for alias:[%s]".formatted(alias));
49+
}
50+
return constant;
51+
}
52+
}

‎rlib-common/src/main/java/javasabr/rlib/common/util/StringUtils.java‎

Lines changed: 34 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -37,16 +37,27 @@ public static String emptyIfNull(@Nullable String string) {
3737
}
3838

3939
/**
40-
* Return the another string if the received string is empty.
40+
* Return the another string if the received string is empty or null.
4141
*
4242
* @param string the string.
4343
* @param another the another string.
44-
* @return the another string if the received string is empty.
44+
* @return the another string if the received string is empty or null.
4545
*/
4646
public static String ifEmpty(@Nullable String string, String another) {
4747
return isEmpty(string) ? another : string;
4848
}
4949

50+
/**
51+
* Return the another string if the received string is blank or null.
52+
*
53+
* @param string the string.
54+
* @param another the another string.
55+
* @return the another string if the received string is blank or null.
56+
*/
57+
public static String ifBlank(@Nullable String string, String another) {
58+
return isBlank(string) ? another : string;
59+
}
60+
5061
/**
5162
* Check a string email.
5263
*
@@ -212,7 +223,7 @@ private static MessageDigest getHashMD5() {
212223
}
213224

214225
/**
215-
* Returns true if the string empty or null.
226+
* Returns true if the string is empty or null.
216227
*
217228
* @param string the string.
218229
* @return true if the string is null or empty.
@@ -221,6 +232,16 @@ public static boolean isEmpty(@Nullable String string) {
221232
return string == null || string.isEmpty();
222233
}
223234

235+
/**
236+
* Returns true if the string is blank or null.
237+
*
238+
* @param string the string.
239+
* @return true if the string is null or blank.
240+
*/
241+
public static boolean isBlank(@Nullable String string) {
242+
return string == null || string.isBlank();
243+
}
244+
224245
/**
225246
* Returns true if the string isn't empty.
226247
*
@@ -231,6 +252,16 @@ public static boolean isNotEmpty(@Nullable String string) {
231252
return !isEmpty(string);
232253
}
233254

255+
/**
256+
* Returns true if the string isn't blank.
257+
*
258+
* @param string the string.
259+
* @return true if the string isn't blank.
260+
*/
261+
public static boolean isNotBlank(@Nullable String string) {
262+
return !isBlank(string);
263+
}
264+
234265
/**
235266
* Gets the length of the string.
236267
*

‎rlib-common/src/test/java/javasabr/rlib/common/util/AliasedEnumMapTest.java‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
package javasabr.rlib.common.util;
2+
3+
import static org.assertj.core.api.Assertions.assertThat;
4+
import static org.assertj.core.api.Assertions.assertThatThrownBy;
5+
6+
import java.util.Collection;
7+
import java.util.List;
8+
import java.util.Set;
9+
import javasabr.rlib.common.AliasedEnum;
10+
import org.jspecify.annotations.NonNull;
11+
import org.junit.jupiter.api.Test;
12+
13+
class AliasedEnumMapTest {
14+
15+
public enum TestEnum implements AliasedEnum<@NonNull TestEnum> {
16+
CONSTANT1(Set.of("cnst1", "constant1", "CONSTANT1")),
17+
CONSTANT2(Set.of("cnst2", "constant2", "CONSTANT2")),
18+
CONSTANT3(Set.of("cnst3", "constant3", "CONSTANT3")),
19+
CONSTANT4(Set.of("cnst4", "constant4", "CONSTANT4")),
20+
CONSTANT5(Set.of("cnst5", "constant5", "CONSTANT5"));
21+
22+
private static final AliasedEnumMap<TestEnum> MAP = new AliasedEnumMap<>(TestEnum.class);
23+
24+
private final Collection<String> aliases;
25+
26+
TestEnum(Collection<String> aliases) {
27+
this.aliases = aliases;
28+
}
29+
30+
@Override
31+
public Collection<String> aliases() {
32+
return aliases;
33+
}
34+
}
35+
36+
@Test
37+
void shouldResolveEnumByAlias() {
38+
// when\then:
39+
assertThat(TestEnum.MAP.resolve("cnst1")).isEqualTo(TestEnum.CONSTANT1);
40+
assertThat(TestEnum.MAP.resolve("constant1")).isEqualTo(TestEnum.CONSTANT1);
41+
assertThat(TestEnum.MAP.resolve("CONSTANT1")).isEqualTo(TestEnum.CONSTANT1);
42+
assertThat(TestEnum.MAP.resolve("cnst2")).isEqualTo(TestEnum.CONSTANT2);
43+
assertThat(TestEnum.MAP.resolve("CONSTANT2")).isEqualTo(TestEnum.CONSTANT2);
44+
assertThat(TestEnum.MAP.resolve("constant3")).isEqualTo(TestEnum.CONSTANT3);
45+
assertThat(TestEnum.MAP.resolve("CONSTANT4")).isEqualTo(TestEnum.CONSTANT4);
46+
assertThat(TestEnum.MAP.resolve("unkonwn")).isNull();
47+
assertThat(TestEnum.MAP.resolve("")).isNull();
48+
assertThat(TestEnum.MAP.resolve("unknown", TestEnum.CONSTANT4)).isEqualTo(TestEnum.CONSTANT4);
49+
}
50+
51+
@Test
52+
void shouldRequireEnumByAlias() {
53+
// when\then:
54+
assertThat(TestEnum.MAP.require("cnst1")).isEqualTo(TestEnum.CONSTANT1);
55+
assertThat(TestEnum.MAP.require("CONSTANT2")).isEqualTo(TestEnum.CONSTANT2);
56+
assertThat(TestEnum.MAP.require("cnst3")).isEqualTo(TestEnum.CONSTANT3);
57+
assertThat(TestEnum.MAP.require("constant4")).isEqualTo(TestEnum.CONSTANT4);
58+
assertThatThrownBy(() -> TestEnum.MAP.require("unknown"))
59+
.isInstanceOf(IllegalArgumentException.class);
60+
assertThatThrownBy(() -> TestEnum.MAP.require(""))
61+
.isInstanceOf(IllegalArgumentException.class);
62+
}
63+
}

‎rlib-common/src/test/java/javasabr/rlib/common/util/StringUtilsTest.java‎

Lines changed: 54 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,6 @@ void shouldThrownIllegalArgumentExceptionDuringReplacingStringWithWrongArgs() {
103103

104104
@Test
105105
void shouldVerifyEmails() {
106-
107106
Assertions.assertTrue(StringUtils.isValidEmail("test@test.com"));
108107
Assertions.assertTrue(StringUtils.isValidEmail("тест@test.com"));
109108
Assertions.assertTrue(StringUtils.isValidEmail("тест@тест.рф"));
@@ -116,7 +115,6 @@ void shouldVerifyEmails() {
116115

117116
@Test
118117
void shouldDetectEmails() {
119-
120118
Assertions.assertTrue(StringUtils.isEmail("test@test.com"));
121119
Assertions.assertTrue(StringUtils.isEmail("test.test@test.com"));
122120
Assertions.assertTrue(StringUtils.isEmail("test.test@test.test.com"));
@@ -126,4 +124,58 @@ void shouldDetectEmails() {
126124
Assertions.assertFalse(StringUtils.isEmail("test@test"));
127125
Assertions.assertFalse(StringUtils.isEmail("test@test."));
128126
}
127+
128+
@Test
129+
void shouldCheckIfStringIsEmpty() {
130+
Assertions.assertTrue(StringUtils.isEmpty(null));
131+
Assertions.assertFalse(StringUtils.isNotEmpty(null));
132+
133+
Assertions.assertTrue(StringUtils.isEmpty(""));
134+
Assertions.assertFalse(StringUtils.isNotEmpty(""));
135+
136+
Assertions.assertFalse(StringUtils.isEmpty(" "));
137+
Assertions.assertTrue(StringUtils.isNotEmpty(" "));
138+
139+
Assertions.assertFalse(StringUtils.isEmpty("123"));
140+
Assertions.assertTrue(StringUtils.isNotEmpty("123"));
141+
}
142+
143+
@Test
144+
void shouldReturnAnotherStringIfEmpty() {
145+
Assertions.assertEquals("alt", StringUtils.ifEmpty(null, "alt"));
146+
Assertions.assertEquals("alt", StringUtils.ifEmpty("", "alt"));
147+
Assertions.assertEquals(" ", StringUtils.ifEmpty(" ", "alt"));
148+
Assertions.assertEquals("123", StringUtils.ifEmpty("123", "alt"));
149+
}
150+
151+
@Test
152+
void shouldCheckIfStringIsBlank() {
153+
Assertions.assertTrue(StringUtils.isBlank(null));
154+
Assertions.assertFalse(StringUtils.isNotBlank(null));
155+
156+
Assertions.assertTrue(StringUtils.isBlank(""));
157+
Assertions.assertFalse(StringUtils.isNotBlank(""));
158+
159+
Assertions.assertTrue(StringUtils.isBlank(" "));
160+
Assertions.assertFalse(StringUtils.isNotBlank(" "));
161+
162+
Assertions.assertTrue(StringUtils.isBlank(" "));
163+
Assertions.assertFalse(StringUtils.isNotBlank(" "));
164+
165+
Assertions.assertFalse(StringUtils.isBlank(" 1"));
166+
Assertions.assertTrue(StringUtils.isNotBlank(" 1"));
167+
168+
Assertions.assertFalse(StringUtils.isBlank("123"));
169+
Assertions.assertTrue(StringUtils.isNotBlank("123"));
170+
}
171+
172+
@Test
173+
void shouldReturnAnotherStringIfBlank() {
174+
Assertions.assertEquals("alt", StringUtils.ifBlank(null, "alt"));
175+
Assertions.assertEquals("alt", StringUtils.ifBlank("", "alt"));
176+
Assertions.assertEquals("alt", StringUtils.ifBlank(" ", "alt"));
177+
Assertions.assertEquals("alt", StringUtils.ifBlank(" ", "alt"));
178+
Assertions.assertEquals(" 1", StringUtils.ifBlank(" 1", "alt"));
179+
Assertions.assertEquals("123", StringUtils.ifBlank("123", "alt"));
180+
}
129181
}

0 commit comments

Comments
 (0)