Skip to content

Commit 69bcb39

Browse files
raydacraydac
committed
refactoring
1 parent 625c1ac commit 69bcb39

File tree

9 files changed

+77
-47
lines changed

9 files changed

+77
-47
lines changed

‎src/main/java/com/igormaznitsa/prologparser/PrologParser.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -309,7 +309,7 @@ private PrologTerm readList(final TokenizerResult openingBracket) {
309309

310310
if (rightPart != null
311311
&& rightPart.getTermType() == TermType.STRUCT
312-
&& ((PrologStruct) rightPart).getFunctor().getTermText().equals(OPERATOR_VERTICALBAR.getTermText())) {
312+
&& rightPart.getFunctor().getTermText().equals(OPERATOR_VERTICALBAR.getTermText())) {
313313
throw new PrologParserException(
314314
"Duplicated list tail definition",
315315
tokenizer.getLastTokenLine(),

‎src/main/java/com/igormaznitsa/prologparser/terms/PrologStruct.java‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -140,6 +140,7 @@ public void setElementAt(final int index, final PrologTerm term) {
140140
this.elements[index] = AssertUtils.assertNotNull(term);
141141
}
142142

143+
@Override
143144
public PrologTerm getFunctor() {
144145
return functor;
145146
}

‎src/main/java/com/igormaznitsa/prologparser/terms/PrologTerm.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -143,6 +143,10 @@ public Stream<PrologTerm> stream() {
143143
return Stream.of(this);
144144
}
145145

146+
public PrologTerm getFunctor() {
147+
return this;
148+
}
149+
146150
@Override
147151
public int compareTo(final PrologTerm that) {
148152
if (that instanceof SpecServiceCompound) {

‎src/main/java/com/igormaznitsa/prologparser/tokenizer/TreeItem.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -228,8 +228,8 @@ private boolean isPrecedenceOk() {
228228
private boolean isBlock() {
229229
return this.savedTerm.getTermType() == TermType.STRUCT
230230
&& (
231-
((PrologStruct) this.savedTerm).getFunctor() == Op.VIRTUAL_OPERATOR_BLOCK
232-
|| ((PrologStruct) this.savedTerm).getFunctor() == Op.VIRTUAL_OPERATOR_CURLY_BLOCK
231+
this.savedTerm.getFunctor() == Op.VIRTUAL_OPERATOR_BLOCK
232+
|| this.savedTerm.getFunctor() == Op.VIRTUAL_OPERATOR_CURLY_BLOCK
233233
);
234234
}
235235

@@ -327,7 +327,7 @@ public PrologTerm convertToTermAndRelease() {
327327
if ((thisStruct.getFunctor() == Op.VIRTUAL_OPERATOR_BLOCK || thisStruct.getFunctor() == Op.VIRTUAL_OPERATOR_CURLY_BLOCK)
328328
&& thisStruct.getArity() == 1) {
329329
final PrologTerm thatTerm = thisStruct.getTermAt(0);
330-
if (thatTerm.getTermType() == TermType.STRUCT && (((PrologStruct) thatTerm).getFunctor() == Op.VIRTUAL_OPERATOR_BLOCK || ((PrologStruct) thatTerm).getFunctor() == Op.VIRTUAL_OPERATOR_CURLY_BLOCK)) {
330+
if (thatTerm.getTermType() == TermType.STRUCT && (thatTerm.getFunctor() == Op.VIRTUAL_OPERATOR_BLOCK || thatTerm.getFunctor() == Op.VIRTUAL_OPERATOR_CURLY_BLOCK)) {
331331
result = thatTerm;
332332
} else {
333333
result = thisStruct;

‎src/test/java/com/igormaznitsa/prologparser/IntegrationTest.java‎

Lines changed: 55 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -187,7 +187,7 @@ public void testEndOfStream() {
187187
assertEquals(ATOM, term.getTermType());
188188
assertEquals("world", term.getTermText());
189189

190-
assertThrows(NoSuchElementException.class, () -> parser.next());
190+
assertThrows(NoSuchElementException.class, parser::next);
191191
}
192192

193193
private void checkWrongClauseReadingWithPPE(final String readClause, final int stringPosition) {
@@ -430,10 +430,10 @@ public void testParseOperator() {
430430
((Op) struct.getFunctor()).getOpAssoc());
431431
assertEquals("X", struct.getTermAt(0).getTermText());
432432
assertEquals(TermType.STRUCT, struct.getTermAt(1).getTermType());
433-
assertEquals("+", ((PrologStruct) struct.getTermAt(1)).getFunctor().getTermText());
433+
assertEquals("+", struct.getTermAt(1).getFunctor().getTermText());
434434
assertEquals(OpAssoc.YFX,
435-
((Op) ((PrologStruct) struct.getTermAt(1)).getFunctor()).getOpAssoc());
436-
assertEquals(2, ((PrologStruct) struct.getTermAt(1)).getArity());
435+
((Op) struct.getTermAt(1).getFunctor()).getOpAssoc());
436+
assertEquals(2, struct.getTermAt(1).getArity());
437437
assertEquals("X", ((PrologStruct) struct.getTermAt(1)).getTermAt(0).getTermText());
438438
assertEquals("1", ((PrologStruct) struct.getTermAt(1)).getTermAt(1).getTermText());
439439

@@ -470,9 +470,9 @@ public void testSimilarOperatorInterpretation() {
470470
final StubContext contextStub = new StubContext(operators);
471471
final PrologTerm term = parseEd("+++++++++++ 3.", contextStub).next();
472472

473-
assertSame(firstOperator, ((PrologStruct) term).getFunctor());
474-
assertSame(secondOperator, ((PrologStruct) (((PrologStruct) term).getTermAt(0))).getFunctor());
475-
assertSame(thirdOperator, ((PrologStruct) ((PrologStruct) (((PrologStruct) term).getTermAt(0))).getTermAt(0)).getFunctor());
473+
assertSame(firstOperator, term.getFunctor());
474+
assertSame(secondOperator, ((PrologStruct) term).getTermAt(0).getFunctor());
475+
assertSame(thirdOperator, ((PrologStruct) (((PrologStruct) term).getTermAt(0))).getTermAt(0).getFunctor());
476476

477477
}
478478

@@ -517,7 +517,7 @@ public void testOperatorHierarchy() {
517517

518518
assertEquals(TermType.STRUCT, term.getTermType());
519519
assertEquals("<===>", term.getTermText());
520-
assertEquals(2, ((PrologStruct) term).getArity());
520+
assertEquals(2, term.getArity());
521521
assertEquals(800, term.getPrecedence());
522522

523523
final PrologStruct leftBranch = (PrologStruct) ((PrologStruct) term).getTermAt(0);
@@ -569,8 +569,12 @@ private void assertReadTerms(final int expected, final String resource, final Op
569569
}
570570
}
571571

572+
private ParserContext makeSictusContext(final Op... ops) {
573+
return of(ParserContext.FLAG_BLOCK_COMMENTS | ParserContext.FLAG_CURLY_BRACKETS_ALLOWED, Op.join(Op.ISO, Op.SICTUS_SPECIFIC, Arrays.asList(ops)));
574+
}
575+
572576
private void assertReadSictusTerms(final int expected, final String resource, final Op... ops) {
573-
final ParserContext defaultContext = of(ParserContext.FLAG_BLOCK_COMMENTS | ParserContext.FLAG_CURLY_BRACKETS_ALLOWED, Op.join(Op.ISO, Op.SICTUS_SPECIFIC, Arrays.asList(ops)));
577+
final ParserContext defaultContext = makeSictusContext(ops);
574578
try (Reader reader = new InputStreamReader(getClass().getResourceAsStream("bench/" + resource), StandardCharsets.UTF_8)) {
575579
final PrologParser parser = new GenericPrologParser(reader, defaultContext);
576580
assertEquals(expected, parser.stream().count());
@@ -587,6 +591,28 @@ public void testCurlyBracket() {
587591
assertThrows(PrologParserException.class, () -> new GenericPrologParser(new StringReader("test{1,2,3,4,5}."), of(FLAG_CURLY_BRACKETS_ALLOWED)).next());
588592
}
589593

594+
@Test
595+
public void testOperatorExamplesFromSictusManual() {
596+
final ParserContext sictusContext = makeSictusContext();
597+
598+
PrologParser parser = new GenericPrologParser(new StringReader(":-(p;q),r."), sictusContext);
599+
600+
PrologTerm term = parser.next();
601+
assertFalse(parser.hasNext());
602+
603+
assertEquals(":-", term.getFunctor().getTermText());
604+
assertEquals(1, term.getArity());
605+
term = ((PrologStruct) term).getTermAt(0);
606+
assertEquals(",", term.getFunctor().getTermText());
607+
assertEquals("r", ((PrologStruct) term).getTermAt(1).getTermText());
608+
term = ((PrologStruct) term).getTermAt(0);
609+
assertEquals("()", term.getFunctor().getTermText());
610+
term = ((PrologStruct) term).getTermAt(0);
611+
assertEquals(";", term.getFunctor().getTermText());
612+
assertEquals("p", ((PrologStruct) term).getTermAt(0).getTermText());
613+
assertEquals("q", ((PrologStruct) term).getTermAt(1).getTermText());
614+
}
615+
590616
@Test
591617
public void testParseSictusBench() {
592618
assertReadSictusTerms(136, "boyer.pl");
@@ -786,7 +812,7 @@ public void testRecognizingUserOperatorsWhichSimilarMetaOperators() {
786812

787813
final PrologStruct structure = (PrologStruct) parseEd("(((hello....", stubContext).next();
788814
assertEquals("...", structure.getFunctor().getTermText());
789-
assertEquals("(((", ((PrologStruct) structure.getTermAt(0)).getFunctor().getTermText());
815+
assertEquals("(((", structure.getTermAt(0).getFunctor().getTermText());
790816
assertEquals("hello", ((PrologStruct) structure.getTermAt(0)).getTermAt(0).getTermText());
791817
}
792818

@@ -890,9 +916,9 @@ public void testVeryLongStructure() {
890916
@Test
891917
public void testParserStream() {
892918
PrologParser parser = parseEd("z(some).a(X):-[X].b('\\'hello world\\'').list([_|Tail]) :- list(Tail).");
893-
final String joined = parser.stream().map(x -> x.toString()).collect(joining(". ", "", "."));
919+
final String joined = parser.stream().map(PrologTerm::toString).collect(joining(". ", "", "."));
894920
parser = parseEd(joined);
895-
assertEquals(joined, parser.stream().map(x -> x.toString()).collect(joining(". ", "", ".")));
921+
assertEquals(joined, parser.stream().map(PrologTerm::toString).collect(joining(". ", "", ".")));
896922
assertEquals("z(some). a(X) :- [X]. b('\\'hello world\\''). list([_|Tail]) :- list(Tail).", joined);
897923
}
898924

@@ -906,7 +932,7 @@ public void testStructStream() {
906932
"5\n" +
907933
"6\n" +
908934
"7\n" +
909-
"8", parser.next().stream().map(x -> x.toString()).collect(joining("\n")));
935+
"8", parser.next().stream().map(PrologTerm::toString).collect(joining("\n")));
910936
}
911937

912938
@Test
@@ -920,7 +946,7 @@ public void testListStream() {
920946
"6\n" +
921947
"7\n" +
922948
"8\n" +
923-
"_", parser.next().stream().map(x -> x.toString()).collect(joining("\n")));
949+
"_", parser.next().stream().map(PrologTerm::toString).collect(joining("\n")));
924950
}
925951

926952

@@ -978,22 +1004,22 @@ public void testSignedNumerics_GenericParser() {
9781004
}
9791005

9801006
@Test
981-
public void testMisc() throws Exception {
1007+
public void testMisc() {
9821008
assertNotNull(parseEd("''(123_345)**[].").next());
9831009
assertEquals("'+'", parseEd("+.").next().toString());
9841010
assertEquals("some(a, '+', b)", parseEd("some(a,+,b).").next().toString());
9851011
assertEquals("some('+', '+', '+')", parseEd("some(+,+,+).").next().toString());
9861012
}
9871013

9881014
@Test
989-
public void testParseBigGeneratedPrologSource() throws Exception {
1015+
public void testParseBigGeneratedPrologSource() {
9901016
final int CLAUSES = 1000;
9911017
assertEquals(CLAUSES, new GenericPrologParser(new InputStreamReader(new PrologSourceKoi7Generator(CLAUSES, true)), DefaultParserContext.of(FLAG_NONE, Op.SWI)).stream().count());
9921018
assertEquals(CLAUSES, new GenericPrologParser(new InputStreamReader(new PrologSourceKoi7Generator(CLAUSES, false)), DefaultParserContext.of(FLAG_NONE, Op.SWI)).stream().count());
9931019
}
9941020

9951021
@Test
996-
public void testNonCompletedClause() throws Exception {
1022+
public void testNonCompletedClause() {
9971023
assertThrows(PrologParserException.class, () -> parseEd("a").next());
9981024
assertThrows(PrologParserException.class, () -> parseEd("123").next());
9991025
assertThrows(PrologParserException.class, () -> parseEd("\"dsdsd\"").next());
@@ -1008,12 +1034,12 @@ private void assertOperatorAsFunctor(final String expected, final PrologTerm ter
10081034
assertTrue(term instanceof PrologStruct);
10091035
final PrologStruct struct = (PrologStruct) term;
10101036
assertEquals(TermType.OPERATOR, struct.getFunctor().getTermType());
1011-
assertEquals(((Op) struct.getFunctor()).getArity(), struct.getArity());
1037+
assertEquals(struct.getFunctor().getArity(), struct.getArity());
10121038
assertEquals(expected, term.toString());
10131039
}
10141040

10151041
@Test
1016-
public void testOperatorAsFunctor() throws Exception {
1042+
public void testOperatorAsFunctor() {
10171043
assertOperatorAsFunctor("1 + 2", parseEd("+(1,2).").next());
10181044
assertOperatorAsFunctor("1 + 2", parseEd("+(1,2).").next());
10191045
assertOperatorAsFunctor("+ 1", parseEd("+(1).").next());
@@ -1027,7 +1053,7 @@ public void testOperatorAsFunctor() throws Exception {
10271053
}
10281054

10291055
@Test
1030-
public void testPairOfOperatorsWithIncompatiblePrecedence() throws Exception {
1056+
public void testPairOfOperatorsWithIncompatiblePrecedence() {
10311057
assertEquals("- (discontiguous)", parseEd("-discontiguous.").next().toString());
10321058
assertEquals("aab", parseEd("aab.", DefaultParserContext.of(FLAG_NONE, Op.make(400, XF, "aabc"))).next().toString());
10331059
assertEquals("1 - - -1", parseEd("1---1.").next().toString());
@@ -1043,7 +1069,7 @@ public void testPairOfOperatorsWithIncompatiblePrecedence() throws Exception {
10431069
}
10441070

10451071
@Test
1046-
public void testOperatorAsFunctorWithUnsupportedArity() throws Exception {
1072+
public void testOperatorAsFunctorWithUnsupportedArity() {
10471073
assertEquals("':'(1, 2, 3)", parseEd(":(1,2,3).").next().toString());
10481074
assertEquals("'+'(1, 2, 3)", parseEd("+(1,2,3).").next().toString());
10491075
assertEquals("':'(1, (2 , 3), 4)", parseEd(":(1,(2,3),4).").next().toString());
@@ -1066,14 +1092,14 @@ public void testBlock() {
10661092
}
10671093

10681094
@Test
1069-
public void testAloneOperatorAsAtom() throws Exception {
1095+
public void testAloneOperatorAsAtom() {
10701096
assertEquals(TermType.ATOM, parseEd("/.").next().getTermType());
10711097
assertEquals(TermType.ATOM, parseEd("-.").next().getTermType());
10721098
assertEquals(TermType.ATOM, parseEd("+.").next().getTermType());
10731099
}
10741100

10751101
@Test
1076-
public void testUnexpectedlyEndedReadStream() throws Exception {
1102+
public void testUnexpectedlyEndedReadStream() {
10771103
final Random rnd = new Random(12345);
10781104

10791105
final AtomicInteger completedClauseCounter = new AtomicInteger();
@@ -1121,14 +1147,14 @@ public void testVarAsFunctor() {
11211147

11221148
final PrologStruct structB = (PrologStruct) new GenericPrologParser(new StringReader("X(a),Y(b),_Z(d)."), DefaultParserContext.of(FLAG_VAR_AS_FUNCTOR)).next();
11231149
assertEquals(structB.getFunctor(), Op.METAOPERATOR_COMMA);
1124-
assertEquals(TermType.VAR, ((PrologStruct) structB.getTermAt(0)).getFunctor().getTermType());
1125-
assertEquals("X", ((PrologStruct) structB.getTermAt(0)).getFunctor().getTermText());
1150+
assertEquals(TermType.VAR, structB.getTermAt(0).getFunctor().getTermType());
1151+
assertEquals("X", structB.getTermAt(0).getFunctor().getTermText());
11261152

11271153
final PrologStruct structC = (PrologStruct) structB.getTermAt(1);
1128-
assertEquals(TermType.VAR, ((PrologStruct) structC.getTermAt(0)).getFunctor().getTermType());
1129-
assertEquals("Y", ((PrologStruct) structC.getTermAt(0)).getFunctor().getTermText());
1130-
assertEquals(TermType.VAR, ((PrologStruct) structC.getTermAt(1)).getFunctor().getTermType());
1131-
assertEquals("_Z", ((PrologStruct) structC.getTermAt(1)).getFunctor().getTermText());
1154+
assertEquals(TermType.VAR, structC.getTermAt(0).getFunctor().getTermType());
1155+
assertEquals("Y", structC.getTermAt(0).getFunctor().getTermText());
1156+
assertEquals(TermType.VAR, structC.getTermAt(1).getFunctor().getTermType());
1157+
assertEquals("_Z", structC.getTermAt(1).getFunctor().getTermText());
11321158
assertEquals("X(a) , Y(b) , _Z(d)", structB.toString());
11331159
}
11341160

‎src/test/java/com/igormaznitsa/prologparser/ParserContextTest.java‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,6 @@
1313

1414
import static org.junit.jupiter.api.Assertions.assertEquals;
1515
import static org.junit.jupiter.api.Assertions.assertThrows;
16-
import static org.mockito.ArgumentMatchers.any;
1716
import static org.mockito.ArgumentMatchers.anyString;
1817
import static org.mockito.Mockito.*;
1918

@@ -29,7 +28,7 @@ public void testHasOperatorStartsWith() {
2928
when(mockContext.getMaxTokenizerBufferLength()).thenReturn(1024);
3029
final GenericPrologParser parser = new GenericPrologParser(new StringReader("a operator b."), mockContext);
3130

32-
assertThrows(PrologParserException.class, () -> parser.next());
31+
assertThrows(PrologParserException.class, parser::next);
3332

3433
verify(mockContext).findOpForName(parser, "a");
3534
verify(mockContext).findOpForName(parser, "operator");
@@ -38,7 +37,7 @@ public void testHasOperatorStartsWith() {
3837
}
3938

4039
@Test
41-
public void testFindOperatorForName() throws Exception {
40+
public void testFindOperatorForName() {
4241
final ParserContext mockContext = mock(ParserContext.class);
4342
when(mockContext.findOpForName(any(GenericPrologParser.class), anyString())).then((InvocationOnMock invocation) -> {
4443
if ("operator".startsWith((String) invocation.getArguments()[1])) {

‎src/test/java/com/igormaznitsa/prologparser/terms/PrologFloatNumberTest.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -19,10 +19,10 @@ public void testToString() {
1919

2020
@Test
2121
public void testNeg() {
22-
assertEquals(345.223d, ((PrologFloat) new PrologFloat(
23-
-345.223d).makeNeg()).getNumber().doubleValue(), Double.MIN_NORMAL);
24-
assertEquals(-0.0003d, ((PrologFloat) new PrologFloat(
25-
0.0003d).makeNeg()).getNumber().doubleValue(), Double.MIN_NORMAL);
22+
assertEquals(345.223d, new PrologFloat(
23+
-345.223d).makeNeg().getNumber().doubleValue(), Double.MIN_NORMAL);
24+
assertEquals(-0.0003d, new PrologFloat(
25+
0.0003d).makeNeg().getNumber().doubleValue(), Double.MIN_NORMAL);
2626
}
2727

2828
@Test

‎src/test/java/com/igormaznitsa/prologparser/terms/PrologIntNumberTest.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,8 @@ public void testToString() {
1818

1919
@Test
2020
public void testNeg() {
21-
assertEquals(-66324377324L, ((PrologInt) new PrologInt("66324377324").makeNeg()).getNumber().longValue());
22-
assertEquals(21334324324L, ((PrologInt) new PrologInt("-21334324324").makeNeg()).getNumber().longValue());
21+
assertEquals(-66324377324L, new PrologInt("66324377324").makeNeg().getNumber().longValue());
22+
assertEquals(21334324324L, new PrologInt("-21334324324").makeNeg().getNumber().longValue());
2323
}
2424

2525
@Test

‎src/test/java/com/igormaznitsa/prologparser/tokenizer/OperatorTest.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -154,11 +154,11 @@ public void testEquals() {
154154
final Op opFX2 = Op.make(100, OpAssoc.FX, "><");
155155
final Op opFY = Op.make(100, OpAssoc.FX, ">*<");
156156

157-
assertFalse(opFX.equals("><"));
158-
assertFalse(opFX.equals(null));
159-
assertTrue(opFX.equals(opFX));
160-
assertTrue(opFX.equals(opFX2));
161-
assertFalse(opFX.equals(opFY));
157+
assertNotEquals("><", opFX);
158+
assertNotEquals(null, opFX);
159+
assertEquals(opFX, opFX);
160+
assertEquals(opFX, opFX2);
161+
assertNotEquals(opFX, opFY);
162162
}
163163

164164
@Test

0 commit comments

Comments
 (0)