Match#capture: flatten multiple values to the same key (#68)

* Match#capture: flatten multiple values to the same key

* Match#capture: remove unused code of flattened change

Author: retoo

src/main/java/io/thekraken/grok/api/Match.java

@@ -16,7 +16,10 @@
 package io.thekraken.grok.api;
 
 
+import static java.lang.String.format;
+
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -26,6 +29,7 @@
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import io.thekraken.grok.api.exception.GrokException;
 
 /**
  * {@code Match} is a representation in {@code Grok} world of your log.
@@ -141,9 +145,32 @@ public String getSubject() {
   /**
    * Match to the <tt>subject</tt> the <tt>regex</tt> and save the matched element into a map.
    *
+   * Multiple values for the same key are stored as list.
+   *
    */
-  @SuppressWarnings("unchecked")
   public void captures() {
+    captures(false);
+
+  }
+
+  /**
+   * Match to the <tt>subject</tt> the <tt>regex</tt> and save the matched element into a map
+   *
+   * Multiple values to the same key are flattened to one value: the sole non-null value will be captured.
+   * Should there be multiple non-null values a RuntimeException is being thrown.
+   *
+   * This can be used in cases like: (foo (.*:message) bar|bar (.*:message) foo) where the regexp guarantees that only
+   * one value will be captured.
+   *
+   * See also {@link #captures} which returns multiple values of the same key as list.
+   *
+   */
+  public void capturesFlattened() {
+    captures(true);
+  }
+
+  @SuppressWarnings("unchecked")
+  private void captures(boolean flattened ) {
     if (match == null) {
       return;
     }
@@ -187,24 +214,36 @@ public void captures() {
       }
 
       if (capture.containsKey(key)) {
-    	Object currentValue = capture.get(key);
-    	if(currentValue instanceof List) {
-          ((List<Object>) currentValue).add(value);
-    	} else {
-    	  List<Object> list = new ArrayList<Object>();
-    	  list.add(currentValue);
-    	  list.add(value);
-    	  capture.put(key, list);
-    	}
+         Object currentValue = capture.get(key);
+
+        if (flattened) {
+          if (currentValue == null && value != null) {
+            capture.put(key, value);
+          } if (currentValue != null && value != null) {
+            throw new RuntimeException(
+                    format("key '%s' has multiple non-null values, this is not allowed in flattened mode, values:'%s', '%s'",
+                            key,
+                            currentValue,
+                            value));
+          }
+        } else {
+          if (currentValue instanceof List) {
+            ((List<Object>) currentValue).add(value);
+          } else {
+            List<Object> list = new ArrayList<Object>();
+            list.add(currentValue);
+            list.add(value);
+            capture.put(key, list);
+          }
+        }
       } else {
-    	capture.put(key, value);
+        capture.put(key, value);
       }
 
       it.remove(); // avoids a ConcurrentModificationException
     }
   }
 
-
   /**
    * remove from the string the quote and double quote.
    *
@@ -294,4 +333,5 @@ private void cleanMap() {
   public Boolean isNull() {
     return this.match == null;
   }
+
 }

src/test/java/io/thekraken/grok/api/CaptureTest.java

@@ -1,17 +1,21 @@
 package io.thekraken.grok.api;
 
-import io.thekraken.grok.api.exception.GrokException;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
-
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.util.List;
 
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import io.thekraken.grok.api.exception.GrokException;
+
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class CaptureTest {
 
@@ -116,4 +120,28 @@ public void test007_captureDuplicateName() throws GrokException {
     	assertEquals(((List<Object>) (m.toMap().get("id"))).get(1),"456");
     }
 
+    @SuppressWarnings("unchecked")
+	@Test
+    public void test008_flattenDuplicateKeys() throws GrokException {
+        grok.compile("(?:foo %{INT:id} bar|bar %{INT:id} foo)");
+        Match m = grok.match("foo 123 bar");
+        m.capturesFlattened();
+        assertEquals(m.toMap().size(), 1);
+        assertEquals(m.toMap().get("id"), "123");
+        Match m2 = grok.match("bar 123 foo");
+        m2.capturesFlattened();
+        assertEquals(m2.toMap().size(), 1);
+        assertEquals(m2.toMap().get("id"), "123");
+
+        grok.compile("%{INT:id} %{INT:id}");
+        Match m3 = grok.match("123 456");
+
+        try {
+            m3.capturesFlattened();
+            fail("should report error due tu ambiguity");
+        } catch (RuntimeException e) {
+            assertThat(e.getMessage(), containsString("has multiple non-null values, this is not allowed in flattened mode"));
+        }
+    }
+
 }