Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

update Restrictions to standardize on attribute terminology #915

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

update Restrictions to standardize on attribute terminology #915

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions api/src/main/java/jakarta/data/BasicRestriction.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,9 +18,9 @@
package jakarta.data;

public interface BasicRestriction<T> extends Restriction<T> {
Operator comparison();
String attribute();

String field();
Operator comparison();

@Override
BasicRestriction<T> negate();
Expand Down
6 changes: 3 additions & 3 deletions api/src/main/java/jakarta/data/BasicRestrictionRecord.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,18 +24,18 @@
import java.util.Objects;

record BasicRestrictionRecord<T>(
String field,
String attribute,
Operator comparison,
Object value) implements BasicRestriction<T> {

BasicRestrictionRecord {
Objects.requireNonNull(field, "Field must not be null");
Objects.requireNonNull(attribute, "Attribute must not be null");
}

@Override
public BasicRestriction<T> negate() {
return new BasicRestrictionRecord<>(
field,
attribute,
comparison.negate(),
value);
}
Expand Down
106 changes: 53 additions & 53 deletions api/src/main/java/jakarta/data/Restrict.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,83 +53,83 @@ public static <T> Restriction<T> any(Restriction<T>... restrictions) {

public static <T, V extends Comparable<V>> Restriction<T> between(V min,
V max,
String field) {
return all(greaterThanEqual(min, field),
lessThanEqual(max, field));
String attribute) {
return all(greaterThanEqual(min, attribute),
lessThanEqual(max, attribute));
}

// TODO Need to think more about how to best cover negation of multiple
// and then make negation of Single consistent with it

public static <T> TextRestriction<T> contains(String substring, String field) {
public static <T> TextRestriction<T> contains(String substring, String attribute) {
String pattern = toLikeEscaped(CHAR_WILDCARD, STRING_WILDCARD, true, substring, true);
return new TextRestrictionRecord<>(field, Operator.LIKE, ESCAPED, pattern);
return new TextRestrictionRecord<>(attribute, Operator.LIKE, ESCAPED, pattern);
}

public static <T> TextRestriction<T> endsWith(String suffix, String field) {
public static <T> TextRestriction<T> endsWith(String suffix, String attribute) {
String pattern = toLikeEscaped(CHAR_WILDCARD, STRING_WILDCARD, true, suffix, false);
return new TextRestrictionRecord<>(field, Operator.LIKE, ESCAPED, pattern);
return new TextRestrictionRecord<>(attribute, Operator.LIKE, ESCAPED, pattern);
}

public static <T> Restriction<T> equalTo(Object value, String field) {
return new BasicRestrictionRecord<>(field, Operator.EQUAL, value);
public static <T> Restriction<T> equalTo(Object value, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.EQUAL, value);
}

public static <T> TextRestriction<T> equalTo(String value, String field) {
return new TextRestrictionRecord<>(field, Operator.EQUAL, value);
public static <T> TextRestriction<T> equalTo(String value, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.EQUAL, value);
}

public static <T, V extends Comparable<V>> Restriction<T> greaterThan(V value, String field) {
return new BasicRestrictionRecord<>(field, Operator.GREATER_THAN, value);
public static <T, V extends Comparable<V>> Restriction<T> greaterThan(V value, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.GREATER_THAN, value);
}

public static <T> TextRestriction<T> greaterThan(String value, String field) {
return new TextRestrictionRecord<>(field, Operator.GREATER_THAN, value);
public static <T> TextRestriction<T> greaterThan(String value, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.GREATER_THAN, value);
}

public static <T, V extends Comparable<V>> Restriction<T> greaterThanEqual(V value, String field) {
return new BasicRestrictionRecord<>(field, Operator.GREATER_THAN_EQUAL, value);
public static <T, V extends Comparable<V>> Restriction<T> greaterThanEqual(V value, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.GREATER_THAN_EQUAL, value);
}

public static <T> TextRestriction<T> greaterThanEqual(String value, String field) {
return new TextRestrictionRecord<>(field, Operator.GREATER_THAN_EQUAL, value);
public static <T> TextRestriction<T> greaterThanEqual(String value, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.GREATER_THAN_EQUAL, value);
}

public static <T> Restriction<T> in(Set<Object> values, String field) {
return new BasicRestrictionRecord<>(field, Operator.IN, values);
public static <T> Restriction<T> in(Set<Object> values, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.IN, values);
}

public static <T, V extends Comparable<V>> Restriction<T> lessThan(V value, String field) {
return new BasicRestrictionRecord<>(field, Operator.LESS_THAN, value);
public static <T, V extends Comparable<V>> Restriction<T> lessThan(V value, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.LESS_THAN, value);
}

public static <T> TextRestriction<T> lessThan(String value, String field) {
return new TextRestrictionRecord<>(field, Operator.LESS_THAN, value);
public static <T> TextRestriction<T> lessThan(String value, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.LESS_THAN, value);
}

public static <T, V extends Comparable<V>> Restriction<T> lessThanEqual(V value, String field) {
return new BasicRestrictionRecord<>(field, Operator.LESS_THAN_EQUAL, value);
public static <T, V extends Comparable<V>> Restriction<T> lessThanEqual(V value, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.LESS_THAN_EQUAL, value);
}

public static <T> TextRestriction<T> lessThanEqual(String value, String field) {
return new TextRestrictionRecord<>(field, Operator.LESS_THAN_EQUAL, value);
public static <T> TextRestriction<T> lessThanEqual(String value, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.LESS_THAN_EQUAL, value);
}

// TODO this would be possible if Pattern is added, but is it even useful?
//public static <T> TextRestriction<T> like(Pattern pattern, String field) {
// return new TextRestriction<>(field, Operator.LIKE, ESCAPED, pattern);
//public static <T> TextRestriction<T> like(Pattern pattern, String attribute) {
// return new TextRestriction<>(attribute, Operator.LIKE, ESCAPED, pattern);
//}

public static <T> TextRestriction<T> like(String pattern, String field) {
return new TextRestrictionRecord<>(field, Operator.LIKE, pattern);
public static <T> TextRestriction<T> like(String pattern, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.LIKE, pattern);
}

public static <T> TextRestriction<T> like(String pattern,
char charWildcard,
char stringWildcard,
String field) {
String attribute) {
String p = toLikeEscaped(charWildcard, stringWildcard, false, pattern, false);
return new TextRestrictionRecord<>(field, Operator.LIKE, ESCAPED, p);
return new TextRestrictionRecord<>(attribute, Operator.LIKE, ESCAPED, p);
}

// convenience method for those who would prefer to avoid .negate()
Expand All @@ -138,48 +138,48 @@ public static <T> Restriction<T> not(Restriction<T> restriction) {
return restriction.negate();
}

public static <T> Restriction<T> notEqualTo(Object value, String field) {
return new BasicRestrictionRecord<>(field, Operator.NOT_EQUAL, value);
public static <T> Restriction<T> notEqualTo(Object value, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.NOT_EQUAL, value);
}

public static <T> TextRestriction<T> notEqualTo(String value, String field) {
return new TextRestrictionRecord<>(field, Operator.NOT_EQUAL, value);
public static <T> TextRestriction<T> notEqualTo(String value, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.NOT_EQUAL, value);
}

public static <T> TextRestriction<T> notContains(String substring, String field) {
public static <T> TextRestriction<T> notContains(String substring, String attribute) {
String pattern = toLikeEscaped(CHAR_WILDCARD, STRING_WILDCARD, true, substring, true);
return new TextRestrictionRecord<>(field, Operator.NOT_LIKE, ESCAPED, pattern);
return new TextRestrictionRecord<>(attribute, Operator.NOT_LIKE, ESCAPED, pattern);
}

public static <T> TextRestriction<T> notEndsWith(String suffix, String field) {
public static <T> TextRestriction<T> notEndsWith(String suffix, String attribute) {
String pattern = toLikeEscaped(CHAR_WILDCARD, STRING_WILDCARD, true, suffix, false);
return new TextRestrictionRecord<>(field, Operator.NOT_LIKE, ESCAPED, pattern);
return new TextRestrictionRecord<>(attribute, Operator.NOT_LIKE, ESCAPED, pattern);
}

public static <T> Restriction<T> notIn(Set<Object> values, String field) {
return new BasicRestrictionRecord<>(field, Operator.NOT_IN, values);
public static <T> Restriction<T> notIn(Set<Object> values, String attribute) {
return new BasicRestrictionRecord<>(attribute, Operator.NOT_IN, values);
}

public static <T> TextRestriction<T> notLike(String pattern, String field) {
return new TextRestrictionRecord<>(field, Operator.NOT_LIKE, pattern);
public static <T> TextRestriction<T> notLike(String pattern, String attribute) {
return new TextRestrictionRecord<>(attribute, Operator.NOT_LIKE, pattern);
}

public static <T> TextRestriction<T> notLike(String pattern,
char charWildcard,
char stringWildcard,
String field) {
String attribute) {
String p = toLikeEscaped(charWildcard, stringWildcard, false, pattern, false);
return new TextRestrictionRecord<>(field, Operator.NOT_LIKE, ESCAPED, p);
return new TextRestrictionRecord<>(attribute, Operator.NOT_LIKE, ESCAPED, p);
}

public static <T> TextRestriction<T> notStartsWith(String prefix, String field) {
public static <T> TextRestriction<T> notStartsWith(String prefix, String attribute) {
String pattern = toLikeEscaped(CHAR_WILDCARD, STRING_WILDCARD, false, prefix, true);
return new TextRestrictionRecord<>(field, Operator.NOT_LIKE, ESCAPED, pattern);
return new TextRestrictionRecord<>(attribute, Operator.NOT_LIKE, ESCAPED, pattern);
}

public static <T> TextRestriction<T> startsWith(String prefix, String field) {
public static <T> TextRestriction<T> startsWith(String prefix, String attribute) {
String pattern = toLikeEscaped(CHAR_WILDCARD, STRING_WILDCARD, false, prefix, true);
return new TextRestrictionRecord<>(field, Operator.LIKE, ESCAPED, pattern);
return new TextRestrictionRecord<>(attribute, Operator.LIKE, ESCAPED, pattern);
}

/**
Expand Down
8 changes: 4 additions & 4 deletions api/src/main/java/jakarta/data/TextRestrictionRecord.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,14 +24,14 @@
import java.util.Objects;

record TextRestrictionRecord<T>(
String field,
String attribute,
Operator comparison,
boolean isCaseSensitive,
boolean isEscaped,
String value) implements TextRestriction<T> {

TextRestrictionRecord {
Objects.requireNonNull(field, "Field must not be null");
Objects.requireNonNull(attribute, "Attribute must not be null");
}

TextRestrictionRecord(String field, Operator comparison, boolean escaped, String value) {
Expand All @@ -44,14 +44,14 @@ record TextRestrictionRecord<T>(

@Override
public TextRestriction<T> ignoreCase() {
return new TextRestrictionRecord<>(field, comparison, false, isEscaped, value);
return new TextRestrictionRecord<>(attribute, comparison, false, isEscaped, value);
}

@Override
public TextRestriction<T> negate() {

return new TextRestrictionRecord<>(
field,
attribute,
comparison.negate(),
isCaseSensitive,
isEscaped,
Expand Down
12 changes: 6 additions & 6 deletions api/src/test/java/jakarta/data/BasicRestrictionRecordTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ void shouldCreateBasicRestrictionWithDefaultNegation() {
BasicRestrictionRecord<String> restriction = new BasicRestrictionRecord<>("title", Operator.EQUAL, "Java Guide");

SoftAssertions.assertSoftly(soft -> {
soft.assertThat(restriction.field()).isEqualTo("title");
soft.assertThat(restriction.attribute()).isEqualTo("title");
soft.assertThat(restriction.comparison()).isEqualTo(Operator.EQUAL);
soft.assertThat(restriction.value()).isEqualTo("Java Guide");
});
Expand All @@ -46,7 +46,7 @@ void shouldCreateBasicRestrictionWithExplicitNegation() {
.negate();

SoftAssertions.assertSoftly(soft -> {
soft.assertThat(restriction.field()).isEqualTo("title");
soft.assertThat(restriction.attribute()).isEqualTo("title");
soft.assertThat(restriction.comparison()).isEqualTo(Operator.NOT_EQUAL);
soft.assertThat(restriction.value()).isEqualTo("Java Guide");
});
Expand All @@ -58,7 +58,7 @@ void shouldCreateBasicRestrictionWithNullValue() {
BasicRestrictionRecord<String> restriction = new BasicRestrictionRecord<>("title", Operator.EQUAL, null);

SoftAssertions.assertSoftly(soft -> {
soft.assertThat(restriction.field()).isEqualTo("title");
soft.assertThat(restriction.attribute()).isEqualTo("title");
soft.assertThat(restriction.comparison()).isEqualTo(Operator.EQUAL);
soft.assertThat(restriction.value()).isNull();
});
Expand Down Expand Up @@ -114,16 +114,16 @@ void shouldSupportNegatedRestrictionUsingDefaultConstructor() {
(BasicRestriction<Book>) Restrict.<Book>notEqualTo((Object) "Unknown", "author");

SoftAssertions.assertSoftly(soft -> {
soft.assertThat(negatedRestriction.field()).isEqualTo("author");
soft.assertThat(negatedRestriction.attribute()).isEqualTo("author");
soft.assertThat(negatedRestriction.comparison()).isEqualTo(Operator.NOT_EQUAL);
soft.assertThat(negatedRestriction.value()).isEqualTo("Unknown");
});
}

@Test
void shouldThrowExceptionWhenFieldIsNull() {
void shouldThrowExceptionWhenAttributeIsNull() {
assertThatThrownBy(() -> new BasicRestrictionRecord<>(null, Operator.EQUAL, "testValue"))
.isInstanceOf(NullPointerException.class)
.hasMessage("Field must not be null");
.hasMessage("Attribute must not be null");
}
}
Loading
Loading