Skip to content

Commit 2cb69b2

Browse files
codecholericcodecholeric
committed
Some minor review changes of simple name conditions:
- I've removed AndSimpleName, since the only thing with a simple name so far is JavaClass, and I can't think of any other future case - I've named everything consistently 'simple name', not 'simple class name', since the existing predicate refers just to 'simple name', and within the syntax, it should be clear that it refers to classes PR: #40 Issue: #41
1 parent f5fb175 commit 2cb69b2

File tree

8 files changed

+128
-143
lines changed

8 files changed

+128
-143
lines changed

‎archunit/src/main/java/com/tngtech/archunit/core/domain/JavaClass.java‎

Lines changed: 22 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@
5454
import static com.tngtech.archunit.core.domain.properties.CanBeAnnotated.Utils.toAnnotationOfType;
5555
import static com.tngtech.archunit.core.domain.properties.HasName.Functions.GET_NAME;
5656

57-
public class JavaClass implements HasName.AndSimpleName, HasAnnotations, HasModifiers {
57+
public class JavaClass implements HasName, HasAnnotations, HasModifiers {
5858
private final Optional<Source> source;
5959
private final JavaType javaType;
6060
private final boolean isInterface;
@@ -106,7 +106,7 @@ public String getName() {
106106
return javaType.getName();
107107
}
108108

109-
@Override
109+
@PublicAPI(usage = ACCESS)
110110
public String getSimpleName() {
111111
return javaType.getSimpleName();
112112
}
@@ -784,6 +784,26 @@ public static DescribedPredicate<JavaClass> simpleName(final String name) {
784784
return equalTo(name).onResultOf(GET_SIMPLE_NAME).as("simple name '%s'", name);
785785
}
786786

787+
@PublicAPI(usage = ACCESS)
788+
public static DescribedPredicate<JavaClass> simpleNameStartingWith(final String prefix) {
789+
return new DescribedPredicate<JavaClass>(String.format("simple name starting with '%s'", prefix)) {
790+
@Override
791+
public boolean apply(JavaClass input) {
792+
return input.getSimpleName().startsWith(prefix);
793+
}
794+
};
795+
}
796+
797+
@PublicAPI(usage = ACCESS)
798+
public static DescribedPredicate<JavaClass> simpleNameEndingWith(final String suffix) {
799+
return new DescribedPredicate<JavaClass>(String.format("simple name ending with '%s'", suffix)) {
800+
@Override
801+
public boolean apply(JavaClass input) {
802+
return input.getSimpleName().endsWith(suffix);
803+
}
804+
};
805+
}
806+
787807
@PublicAPI(usage = ACCESS)
788808
public static DescribedPredicate<JavaClass> assignableTo(final Class<?> type) {
789809
return assignableTo(type.getName());

‎archunit/src/main/java/com/tngtech/archunit/core/domain/properties/HasName.java‎

Lines changed: 0 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -32,11 +32,6 @@ interface AndFullName extends HasName {
3232
String getFullName();
3333
}
3434

35-
interface AndSimpleName extends HasName {
36-
@PublicAPI(usage = ACCESS)
37-
String getSimpleName();
38-
}
39-
4035
final class Predicates {
4136
private Predicates() {
4237
}
@@ -55,26 +50,6 @@ public boolean apply(HasName input) {
5550
};
5651
}
5752

58-
@PublicAPI(usage = ACCESS)
59-
public static DescribedPredicate<AndSimpleName> simpleClassNameStartingWith(final String prefix) {
60-
return new DescribedPredicate<AndSimpleName>(String.format("simple class name starting with '%s'", prefix)) {
61-
@Override
62-
public boolean apply(AndSimpleName input) {
63-
return input.getSimpleName().startsWith(prefix);
64-
}
65-
};
66-
}
67-
68-
@PublicAPI(usage = ACCESS)
69-
public static DescribedPredicate<AndSimpleName> simpleClassNameEndingWith(final String suffix) {
70-
return new DescribedPredicate<AndSimpleName>(String.format("simple class name ending with '%s'", suffix)) {
71-
@Override
72-
public boolean apply(AndSimpleName input) {
73-
return input.getSimpleName().endsWith(suffix);
74-
}
75-
};
76-
}
77-
7853
@PublicAPI(usage = ACCESS)
7954
public static DescribedPredicate<HasName> name(final String name) {
8055
return new DescribedPredicate<HasName>(String.format("name '%s'", name)) {

‎archunit/src/main/java/com/tngtech/archunit/lang/conditions/ArchConditions.java‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -52,14 +52,14 @@
5252
import static com.tngtech.archunit.core.domain.Formatters.ensureSimpleName;
5353
import static com.tngtech.archunit.core.domain.JavaClass.Functions.GET_PACKAGE;
5454
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleName;
55+
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleNameEndingWith;
56+
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleNameStartingWith;
5557
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.type;
5658
import static com.tngtech.archunit.core.domain.JavaClass.namesOf;
5759
import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME;
5860
import static com.tngtech.archunit.core.domain.properties.HasModifiers.Predicates.modifier;
5961
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.name;
60-
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.simpleClassNameEndingWith;
6162
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.nameMatching;
62-
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.simpleClassNameStartingWith;
6363
import static com.tngtech.archunit.core.domain.properties.HasOwner.Predicates.With.owner;
6464
import static com.tngtech.archunit.core.domain.properties.HasParameterTypes.Predicates.parameterTypes;
6565
import static com.tngtech.archunit.lang.conditions.ArchPredicates.be;
@@ -313,43 +313,43 @@ public static ArchCondition<JavaClass> notHaveSimpleName(String name) {
313313
}
314314

315315
@PublicAPI(usage = ACCESS)
316-
public static ArchCondition<JavaClass> haveSimpleClassNameStartingWith(final String prefix) {
317-
final DescribedPredicate<HasName.AndSimpleName> predicate = have(simpleClassNameStartingWith(prefix));
316+
public static ArchCondition<JavaClass> haveSimpleNameStartingWith(final String prefix) {
317+
final DescribedPredicate<JavaClass> predicate = have(simpleNameStartingWith(prefix));
318318

319319
return new ArchCondition<JavaClass>(predicate.getDescription()) {
320320
@Override
321321
public void check(JavaClass item, ConditionEvents events) {
322322
boolean satisfied = predicate.apply(item);
323323
String infix = satisfied ? "starts with" : "doesn't start with";
324-
String message = String.format("simple class name of %s %s '%s'", item.getName(), infix, prefix);
324+
String message = String.format("simple name of %s %s '%s'", item.getName(), infix, prefix);
325325
events.add(new SimpleConditionEvent(item, satisfied, message));
326326
}
327327
};
328328
}
329329

330330
@PublicAPI(usage = ACCESS)
331-
public static ArchCondition<JavaClass> haveSimpleClassNameNotStartingWith(String prefix) {
332-
return not(haveSimpleClassNameStartingWith(prefix)).as("have simple class name not starting with '%s'", prefix);
331+
public static ArchCondition<JavaClass> haveSimpleNameNotStartingWith(String prefix) {
332+
return not(haveSimpleNameStartingWith(prefix)).as("have simple name not starting with '%s'", prefix);
333333
}
334334

335335
@PublicAPI(usage = ACCESS)
336-
public static ArchCondition<JavaClass> haveSimpleClassNameEndingWith(final String suffix) {
337-
final DescribedPredicate<HasName.AndSimpleName> predicate = have(simpleClassNameEndingWith(suffix));
336+
public static ArchCondition<JavaClass> haveSimpleNameEndingWith(final String suffix) {
337+
final DescribedPredicate<JavaClass> predicate = have(simpleNameEndingWith(suffix));
338338

339339
return new ArchCondition<JavaClass>(predicate.getDescription()) {
340340
@Override
341341
public void check(JavaClass item, ConditionEvents events) {
342342
boolean satisfied = predicate.apply(item);
343343
String infix = satisfied ? "ends with" : "doesn't end with";
344-
String message = String.format("simple class name of %s %s '%s'", item.getName(), infix, suffix);
344+
String message = String.format("simple name of %s %s '%s'", item.getName(), infix, suffix);
345345
events.add(new SimpleConditionEvent(item, satisfied, message));
346346
}
347347
};
348348
}
349349

350350
@PublicAPI(usage = ACCESS)
351-
public static ArchCondition<JavaClass> haveSimpleClassNameNotEndingWith(String suffix) {
352-
return not(haveSimpleClassNameEndingWith(suffix)).as("have simple class name not ending with '%s'", suffix);
351+
public static ArchCondition<JavaClass> haveSimpleNameNotEndingWith(String suffix) {
352+
return not(haveSimpleNameEndingWith(suffix)).as("have simple name not ending with '%s'", suffix);
353353
}
354354

355355
@PublicAPI(usage = ACCESS)

‎archunit/src/main/java/com/tngtech/archunit/lang/syntax/ClassesShouldInternal.java‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -80,23 +80,23 @@ public ClassesShouldConjunction notHaveSimpleName(String name) {
8080
}
8181

8282
@Override
83-
public ClassesShouldConjunction haveSimpleClassNameStartingWith(String prefix) {
84-
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleClassNameStartingWith(prefix)));
83+
public ClassesShouldConjunction haveSimpleNameStartingWith(String prefix) {
84+
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleNameStartingWith(prefix)));
8585
}
8686

8787
@Override
88-
public ClassesShouldConjunction haveSimpleClassNameNotStartingWith(String prefix) {
89-
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleClassNameNotStartingWith(prefix)));
88+
public ClassesShouldConjunction haveSimpleNameNotStartingWith(String prefix) {
89+
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleNameNotStartingWith(prefix)));
9090
}
9191

9292
@Override
93-
public ClassesShouldConjunction haveSimpleClassNameEndingWith(String suffix) {
94-
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleClassNameEndingWith(suffix)));
93+
public ClassesShouldConjunction haveSimpleNameEndingWith(String suffix) {
94+
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleNameEndingWith(suffix)));
9595
}
9696

9797
@Override
98-
public ClassesShouldConjunction haveSimpleClassNameNotEndingWith(String suffix) {
99-
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleClassNameNotEndingWith(suffix)));
98+
public ClassesShouldConjunction haveSimpleNameNotEndingWith(String suffix) {
99+
return copyWithNewCondition(conditionAggregator.add(ArchConditions.haveSimpleNameNotEndingWith(suffix)));
100100
}
101101

102102
@Override

‎archunit/src/main/java/com/tngtech/archunit/lang/syntax/elements/ClassesShould.java‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -77,38 +77,38 @@ public interface ClassesShould {
7777
/**
7878
* Asserts that classes' simple class names start with a given prefix.
7979
*
80-
* @param prefix A prefix the simple class name should match against
80+
* @param prefix A prefix the simple class name should start with
8181
* @return A syntax element that can either be used as working rule, or to continue specifying a more complex rule
8282
*/
8383
@PublicAPI(usage = ACCESS)
84-
ClassesShouldConjunction haveSimpleClassNameStartingWith(String prefix);
84+
ClassesShouldConjunction haveSimpleNameStartingWith(String prefix);
8585

8686
/**
8787
* Asserts that classes' simple class names do not start with a given prefix.
8888
*
89-
* @param prefix A prefix the simple class name should not match against
89+
* @param prefix A prefix the simple class name should not start with
9090
* @return A syntax element that can either be used as working rule, or to continue specifying a more complex rule
9191
*/
9292
@PublicAPI(usage = ACCESS)
93-
ClassesShouldConjunction haveSimpleClassNameNotStartingWith(String prefix);
93+
ClassesShouldConjunction haveSimpleNameNotStartingWith(String prefix);
9494

9595
/**
9696
* Asserts that classes' simple class names end with a given suffix.
9797
*
98-
* @param suffix A suffix the simple class name should match against
98+
* @param suffix A suffix the simple class name should end with
9999
* @return A syntax element that can either be used as working rule, or to continue specifying a more complex rule
100100
*/
101101
@PublicAPI(usage = ACCESS)
102-
ClassesShouldConjunction haveSimpleClassNameEndingWith(String suffix);
102+
ClassesShouldConjunction haveSimpleNameEndingWith(String suffix);
103103

104104
/**
105105
* Asserts that classes' simple class names do not end with a given suffix.
106106
*
107-
* @param suffix A suffix the simple class name should not match against
107+
* @param suffix A suffix the simple class name should not end with
108108
* @return A syntax element that can either be used as working rule, or to continue specifying a more complex rule
109109
*/
110110
@PublicAPI(usage = ACCESS)
111-
ClassesShouldConjunction haveSimpleClassNameNotEndingWith(String suffix);
111+
ClassesShouldConjunction haveSimpleNameNotEndingWith(String suffix);
112112

113113
/**
114114
* Asserts that classes have a fully qualified class name matching a given regular expression.

‎archunit/src/test/java/com/tngtech/archunit/core/domain/JavaClassTest.java‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,8 @@
3535
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.resideInAPackage;
3636
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.resideInAnyPackage;
3737
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleName;
38+
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleNameEndingWith;
39+
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleNameStartingWith;
3840
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.type;
3941
import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME;
4042
import static com.tngtech.archunit.core.domain.TestUtils.importClassWithContext;
@@ -362,6 +364,42 @@ public void predicate_simpleName() {
362364
assertThat(simpleName("Simple").getDescription()).isEqualTo("simple name 'Simple'");
363365
}
364366

367+
@Test
368+
public void predicate_simpleNameStartingWith() {
369+
JavaClass input = importClassWithContext(Parent.class);
370+
assertThat(simpleNameStartingWith("P").apply(input)).isTrue();
371+
assertThat(simpleNameStartingWith("Pa").apply(input)).isTrue();
372+
assertThat(simpleNameStartingWith("PA").apply(input)).isFalse();
373+
assertThat(simpleNameStartingWith(".P").apply(input)).isFalse();
374+
assertThat(simpleNameStartingWith("").apply(input)).isTrue();
375+
376+
assertThat(simpleNameStartingWith("wrong").apply(input)).isFalse();
377+
378+
// Full match test
379+
assertThat(simpleNameStartingWith(input.getName()).apply(input)).isFalse();
380+
assertThat(simpleNameStartingWith(input.getName().substring(0, 2)).apply(input)).isFalse();
381+
382+
assertThat(simpleNameStartingWith("Prefix").getDescription()).isEqualTo("simple name starting with 'Prefix'");
383+
}
384+
385+
@Test
386+
public void predicate_simpleNameEndingWith() {
387+
JavaClass input = importClassWithContext(Parent.class);
388+
389+
assertThat(simpleNameEndingWith("Parent").apply(input)).isTrue();
390+
assertThat(simpleNameEndingWith("ent").apply(input)).isTrue();
391+
assertThat(simpleNameEndingWith("").apply(input)).isTrue();
392+
393+
// Full match test
394+
assertThat(simpleNameEndingWith(input.getName()).apply(input)).isFalse();
395+
assertThat(simpleNameEndingWith(" ").apply(input)).isFalse();
396+
assertThat(simpleNameEndingWith(".").apply(input)).isFalse();
397+
398+
assertThat(simpleNameEndingWith(".Parent").apply(input)).isFalse();
399+
400+
assertThat(simpleNameEndingWith("Suffix").getDescription()).isEqualTo("simple name ending with 'Suffix'");
401+
}
402+
365403
@Test
366404
public void predicate_assignableFrom() {
367405
assertThatAssignable().from(SuperClassWithFieldAndMethod.class)

‎archunit/src/test/java/com/tngtech/archunit/core/domain/properties/HasNameTest.java‎

Lines changed: 2 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -4,9 +4,7 @@
44
import org.junit.Test;
55

66
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.name;
7-
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.simpleClassNameEndingWith;
87
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.nameMatching;
9-
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.simpleClassNameStartingWith;
108
import static com.tngtech.archunit.testutil.Assertions.assertThat;
119

1210
public class HasNameTest {
@@ -34,62 +32,17 @@ public void match_against_name() {
3432
assertThat(name("some.Foo").getDescription()).isEqualTo("name 'some.Foo'");
3533
}
3634

37-
@Test
38-
public void match_against_prefix() {
39-
HasName.AndSimpleName input = newHasName("some.Foo");
40-
assertThat(simpleClassNameStartingWith("F").apply(input)).isTrue();
41-
assertThat(simpleClassNameStartingWith("Fo").apply(input)).isTrue();
42-
assertThat(simpleClassNameStartingWith("Foo").apply(input)).isTrue();
43-
assertThat(simpleClassNameStartingWith(".Foo").apply(input)).isFalse();
44-
assertThat(simpleClassNameStartingWith("").apply(input)).isTrue();
45-
46-
assertThat(simpleClassNameStartingWith("some").apply(input)).isFalse();
47-
48-
// Full match test
49-
assertThat(simpleClassNameStartingWith("some.Foo").apply(input)).isFalse();
50-
51-
assertThat(simpleClassNameStartingWith("some.Foo").getDescription()).isEqualTo("simple class name starting with 'some.Foo'");
52-
}
53-
54-
@Test
55-
public void match_against_suffix() {
56-
HasName.AndSimpleName input = newHasName("some.Foo");
57-
58-
assertThat(simpleClassNameEndingWith("Foo").apply(input)).isTrue();
59-
assertThat(simpleClassNameEndingWith("").apply(input)).isTrue();
60-
61-
// Full match test
62-
assertThat(simpleClassNameEndingWith("some.Foo").apply(input)).isFalse();
63-
assertThat(simpleClassNameEndingWith(" ").apply(input)).isFalse();
64-
assertThat(simpleClassNameEndingWith(".").apply(input)).isFalse();
65-
66-
assertThat(simpleClassNameEndingWith(".Foo").apply(input)).isFalse();
67-
assertThat(simpleClassNameEndingWith("some.Fo").apply(input)).isFalse();
68-
69-
assertThat(simpleClassNameEndingWith("some.Foo").getDescription()).isEqualTo("simple class name ending with 'some.Foo'");
70-
}
71-
7235
private AbstractBooleanAssert assertMatches(String input, String regex) {
7336
return assertThat(nameMatching(regex).apply(newHasName(input)))
7437
.as(input + " =~ " + regex);
7538
}
7639

77-
private HasName.AndSimpleName newHasName(final String name) {
78-
return new HasName.AndSimpleName() {
40+
private HasName newHasName(final String name) {
41+
return new HasName() {
7942
@Override
8043
public String getName() {
8144
return name;
8245
}
83-
84-
@Override
85-
public String getSimpleName() {
86-
int i = name.lastIndexOf('.');
87-
if (i == -1) {
88-
return name;
89-
}
90-
91-
return name.substring(i + 1);
92-
}
9346
};
9447
}
9548
}

0 commit comments

Comments
 (0)