Added a filter for triples

The filter matches subject, predicate and object against regular
expressions. Triples are only passed on (or filtered) if at least one of
the regexp matches.

Author: cboehme

src/main/java/org/culturegraph/mf/stream/pipe/TripleFilter.java

@@ -0,0 +1,94 @@
+/*
+ *  Copyright 2013 Deutsche Nationalbibliothek
+ *
+ *  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 org.culturegraph.mf.stream.pipe;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.culturegraph.mf.framework.DefaultObjectPipe;
+import org.culturegraph.mf.framework.ObjectReceiver;
+import org.culturegraph.mf.framework.annotations.Description;
+import org.culturegraph.mf.framework.annotations.In;
+import org.culturegraph.mf.framework.annotations.Out;
+import org.culturegraph.mf.types.Triple;
+
+/**
+ * Filters triples. The patterns for subject, predicate and object are disjunctive.
+ *
+ * @author Christoph Böhme
+ *
+ */
+@Description("Filters triple. The  patterns for subject, predicate and object are disjunctive.")
+@In(Triple.class)
+@Out(Triple.class)
+public final class TripleFilter extends
+		DefaultObjectPipe<Triple, ObjectReceiver<Triple>> {
+
+	// A regexp that is guaranteed to never match ( an `a` after the end
+	// of the string, see http://stackoverflow.com/a/1723225 for details):
+	private static final Matcher MATCH_NOTHING = Pattern.compile("$a").matcher("");
+
+	private Matcher subjectMatcher = MATCH_NOTHING;
+	private Matcher predicateMatcher = MATCH_NOTHING;
+	private Matcher objectMatcher = MATCH_NOTHING;
+	private boolean passMatches = true;
+
+	public String getSubjectPattern() {
+		return subjectMatcher.pattern().pattern();
+	}
+
+	public void setSubjectPattern(final String pattern) {
+		subjectMatcher = Pattern.compile(pattern).matcher("");
+	}
+
+	public String getPredicatePattern() {
+		return predicateMatcher.pattern().pattern();
+	}
+
+	public void setPredicatePattern(final String pattern) {
+		predicateMatcher = Pattern.compile(pattern).matcher("");
+	}
+
+	public String getObjectPattern() {
+		return objectMatcher.pattern().pattern();
+	}
+
+	public void setObjectPattern(final String pattern) {
+		objectMatcher = Pattern.compile(pattern).matcher("");
+	}
+
+	public boolean isPassMatches() {
+		return passMatches;
+	}
+
+	public void setPassMatches(final boolean passMatches) {
+		this.passMatches = passMatches;
+	}
+
+	@Override
+	public void process(final Triple obj) {
+		subjectMatcher.reset(obj.getSubject());
+		predicateMatcher.reset(obj.getPredicate());
+		objectMatcher.reset(obj.getObject());
+
+		final boolean matches = subjectMatcher.matches() || predicateMatcher.matches() || objectMatcher.matches();
+
+		if ((matches && passMatches) || (!matches && !passMatches)) {
+			getReceiver().process(obj);
+		}
+	}
+
+}

src/test/java/org/culturegraph/mf/stream/pipe/TripleFilterTest.java

@@ -0,0 +1,95 @@
+/*
+ *  Copyright 2013 Deutsche Nationalbibliothek
+ *
+ *  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 org.culturegraph.mf.stream.pipe;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.culturegraph.mf.framework.ObjectReceiver;
+import org.culturegraph.mf.types.Triple;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Tests for {@link TripleFilter},
+ *
+ * @author Christoph Böhme
+ *
+ */
+public final class TripleFilterTest {
+
+	private static final Triple TRIPLE1 = new Triple("sA", "pA", "oA");
+	private static final Triple TRIPLE2 = new Triple("sB", "pB", "oB");
+	private static final Triple TRIPLE3 = new Triple("sC", "pC", "oC");
+
+	private TripleFilter tripleFilter;
+
+	@Mock
+	private ObjectReceiver<Triple> receiver;
+
+	@Before
+	public void setup() {
+		MockitoAnnotations.initMocks(this);
+		tripleFilter = new TripleFilter();
+		tripleFilter.setReceiver(receiver);
+	}
+
+	@After
+	public void cleanup() {
+		tripleFilter.closeStream();
+	}
+
+	@Test
+	public void testShouldPassMatchingTripleByDefault() {
+		tripleFilter.setSubjectPattern("sA");
+
+		tripleFilter.process(TRIPLE1);
+		tripleFilter.process(TRIPLE2);
+
+		verify(receiver).process(TRIPLE1);
+		verifyNoMoreInteractions(receiver);
+	}
+
+	@Test
+	public void testShouldPassNonMatchingTripleIfPassMatchesIsFalse() {
+		tripleFilter.setSubjectPattern("sA");
+		tripleFilter.setPassMatches(false);
+
+		tripleFilter.process(TRIPLE1);
+		tripleFilter.process(TRIPLE2);
+
+		verify(receiver).process(TRIPLE2);
+		verifyNoMoreInteractions(receiver);
+	}
+
+	@Test
+	public void testShouldUseDisjunctionForPatterns() {
+		tripleFilter.setSubjectPattern("sA");
+		tripleFilter.setObjectPattern("oC");
+
+		tripleFilter.process(TRIPLE1);
+		tripleFilter.process(TRIPLE2);
+		tripleFilter.process(TRIPLE3);
+
+		verify(receiver).process(TRIPLE1);
+		verify(receiver).process(TRIPLE3);
+		verifyNoMoreInteractions(receiver);
+	}
+
+}