layout tree parsing

lib/android/app/src/main/java/com/reactnativenavigation/controllers/CommandsHandler.java

@@ -4,9 +4,6 @@ import android.os.Bundle;
 import android.view.View;
 
 import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.reactnativenavigation.NavigationActivity;
 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.layout.LayoutFactory;
@@ -15,14 +12,11 @@ import com.reactnativenavigation.layout.bottomtabs.BottomTabsCreator;
 import com.reactnativenavigation.layout.parse.LayoutNode;
 import com.reactnativenavigation.utils.UiThread;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 public class CommandsHandler {
 
-	public void setRoot(final NavigationActivity activity, final ReadableMap layoutTree) {
+	public void setRoot(final NavigationActivity activity, final Map<String, Object> layoutTree) {
 		LayoutFactory factory =
 				new LayoutFactory(activity, new LayoutFactory.ReactRootViewCreator() {
 					@Override
@@ -35,12 +29,12 @@ public class CommandsHandler {
 					}
 				}, new BottomTabsCreator());
 
-		final LayoutNode layoutTreeRoot = readableMapToLayoutNode(layoutTree);
+		final LayoutNode layoutTreeRoot = LayoutNode.fromTree(layoutTree);
 		final View rootView = factory.create(layoutTreeRoot);
 		activity.setContentView(rootView);
 	}
 
-	public void push(final NavigationActivity activity, String onContainerId, final ReadableMap layout) {
+	public void push(final NavigationActivity activity, String onContainerId, final Map<String, Object> layoutTree) {
 		LayoutFactory factory =
 				new LayoutFactory(activity, new LayoutFactory.ReactRootViewCreator() {
 					@Override
@@ -52,7 +46,7 @@ public class CommandsHandler {
 						return rootView;
 					}
 				}, new BottomTabsCreator());
-		final LayoutNode layoutNode = readableMapToLayoutNode(layout);
+		final LayoutNode layoutNode = LayoutNode.fromTree(layoutTree);
 		final View rootView = factory.create(layoutNode);
 		((StackLayout) activity.getContentView()).push(rootView);
 	}
@@ -65,35 +59,4 @@ public class CommandsHandler {
 			}
 		});
 	}
-
-	private LayoutNode readableMapToLayoutNode(ReadableMap readableMap) {
-		String id = readableMap.getString("id");
-		LayoutNode.Type type = LayoutNode.Type.fromString(readableMap.getString("type"));
-		Map<String, Object> data = readableMapToJavaMap(readableMap.getMap("data"));
-
-		ReadableArray childrenNodes = readableMap.getArray("children");
-		List<LayoutNode> children = new ArrayList<>(childrenNodes.size());
-		for (int i = 0; i < childrenNodes.size(); i++) {
-			ReadableMap child = childrenNodes.getMap(i);
-			children.add(readableMapToLayoutNode(child));
-		}
-
-		return new LayoutNode(id, type, data, children);
-	}
-
-	private Map<String, Object> readableMapToJavaMap(ReadableMap readableMap) {
-		final Map<String, Object> map = new HashMap<>();
-		for (ReadableMapKeySetIterator it = readableMap.keySetIterator(); it.hasNextKey(); ) {
-			final String key = it.nextKey();
-			switch (readableMap.getType(key)) {
-				case String:
-					map.put(key, readableMap.getString(key));
-					break;
-				case Map:
-					map.put(key, readableMapToJavaMap(readableMap.getMap(key)));
-					break;
-			}
-		}
-		return map;
-	}
 }

lib/android/app/src/main/java/com/reactnativenavigation/layout/parse/LayoutNode.java

@@ -36,4 +36,27 @@ public class LayoutNode {
 		this.data = data;
 		this.children = children;
 	}
+
+	@SuppressWarnings("unchecked")
+	public static LayoutNode fromTree(Map<String, Object> layoutTree) {
+		String id = (String) layoutTree.get("id");
+		LayoutNode.Type type = LayoutNode.Type.fromString((String) layoutTree.get("type"));
+
+		Map<String, Object> data;
+		if (layoutTree.containsKey("data")) {
+			data = (Map<String, Object>) layoutTree.get("data");
+		} else {
+			data = new HashMap<>();
+		}
+
+		List<LayoutNode> children = new ArrayList<>();
+		if (layoutTree.containsKey("children")) {
+			List<Object> rawChildren = (List<Object>) layoutTree.get("children");
+			for (Object rawChild : rawChildren) {
+				children.add(LayoutNode.fromTree((Map<String, Object>) rawChild));
+			}
+		}
+
+		return new LayoutNode(id, type, data, children);
+	}
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/ArgsParser.java

@@ -0,0 +1,82 @@
+package com.reactnativenavigation.react;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ArgsParser {
+	public static Map<String, Object> parse(ReadableMap map) {
+		Map<String, Object> result = new HashMap<>();
+		ReadableMapKeySetIterator it = map.keySetIterator();
+		while (it.hasNextKey()) {
+			String key = it.nextKey();
+			switch (map.getType(key)) {
+				case String:
+					result.put(key, map.getString(key));
+					break;
+				case Number:
+					result.put(key, parseNumber(map, key));
+					break;
+				case Boolean:
+					result.put(key, map.getBoolean(key));
+					break;
+				case Array:
+					result.put(key, parseArray(map.getArray(key)));
+					break;
+				case Map:
+					result.put(key, parse(map.getMap(key)));
+					break;
+				default:
+					break;
+			}
+		}
+		return result;
+	}
+
+	public static List<Object> parseArray(ReadableArray arr) {
+		List<Object> result = new ArrayList<>();
+		for (int i = 0; i < arr.size(); i++) {
+			switch (arr.getType(i)) {
+				case String:
+					result.add(arr.getString(i));
+					break;
+				case Number:
+					result.add(parseNumber(arr, i));
+					break;
+				case Boolean:
+					result.add(arr.getBoolean(i));
+					break;
+				case Array:
+					result.add(parseArray(arr.getArray(i)));
+					break;
+				case Map:
+					result.add(parse(arr.getMap(i)));
+					break;
+				default:
+					break;
+			}
+		}
+		return result;
+	}
+
+	private static Object parseNumber(ReadableMap map, String key) {
+		try {
+			return map.getInt(key);
+		} catch (Exception e) {
+			return map.getDouble(key);
+		}
+	}
+
+	private static Object parseNumber(ReadableArray arr, int index) {
+		try {
+			return arr.getInt(index);
+		} catch (Exception e) {
+			return arr.getDouble(index);
+		}
+	}
+}

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationModule.java

@@ -29,17 +29,17 @@ public class NavigationModule extends ReactContextBaseJavaModule {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				NavigationApplication.instance.getConfig().commandsHandler.setRoot(activity(), layoutTree);
+				NavigationApplication.instance.getConfig().commandsHandler.setRoot(activity(), ArgsParser.parse(layoutTree));
 			}
 		});
 	}
 
 	@ReactMethod
-	public void push(final String onContainerId, final ReadableMap layout) {
+	public void push(final String onContainerId, final ReadableMap layoutTree) {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				NavigationApplication.instance.getConfig().commandsHandler.push(activity(), onContainerId, layout);
+				NavigationApplication.instance.getConfig().commandsHandler.push(activity(), onContainerId, ArgsParser.parse(layoutTree));
 			}
 		});
 	}

lib/android/app/src/test/java/com/reactnativenavigation/layout/parse/LayoutNodeTest.java

@@ -4,7 +4,13 @@ import com.reactnativenavigation.BaseTest;
 
 import org.junit.Test;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.entry;
 
 public class LayoutNodeTest extends BaseTest {
 	@Test
@@ -25,4 +31,32 @@ public class LayoutNodeTest extends BaseTest {
 	public void invalidType() throws Exception {
 		LayoutNode.Type.fromString("unknown");
 	}
+
+	@Test
+	public void parseFromTree() throws Exception {
+		Map<String, Object> tree = new HashMap<>();
+		tree.put("id", "node1");
+		tree.put("type", "ContainerStack");
+		Map<String, Object> rawData = new HashMap<>();
+		rawData.put("dataKey", "dataValue");
+		tree.put("data", rawData);
+		List<Object> rawChildren = new ArrayList<>();
+		Map<String, Object> rawChild = new HashMap<>();
+		rawChild.put("id", "childId1");
+		rawChild.put("type", "Container");
+		rawChildren.add(rawChild);
+		tree.put("children", rawChildren);
+
+		LayoutNode result = LayoutNode.fromTree(tree);
+
+		assertThat(result).isNotNull();
+		assertThat(result.id).isEqualTo("node1");
+		assertThat(result.type).isEqualTo(LayoutNode.Type.ContainerStack);
+		assertThat(result.data).containsOnly(entry("dataKey", "dataValue"));
+		assertThat(result.children).hasSize(1);
+		assertThat(result.children.get(0).id).isEqualTo("childId1");
+		assertThat(result.children.get(0).type).isEqualTo(LayoutNode.Type.Container);
+		assertThat(result.children.get(0).data).isEmpty();
+		assertThat(result.children.get(0).children).isEmpty();
+	}
 }

lib/android/app/src/test/java/com/reactnativenavigation/react/ArgsParserTest.java

@@ -0,0 +1,53 @@
+package com.reactnativenavigation.react;
+
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.reactnativenavigation.BaseTest;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.entry;
+
+public class ArgsParserTest extends BaseTest {
+	@Test
+	public void parsesToMap() throws Exception {
+		JavaOnlyMap input = new JavaOnlyMap();
+		input.putString("keyString", "stringValue");
+		input.putInt("keyInt", 123);
+		input.putDouble("keyDouble", 123.456);
+		input.putBoolean("keyBoolean", true);
+		input.putArray("keyArray", new JavaOnlyArray());
+		input.putNull("bla");
+
+		Map<String, Object> result = ArgsParser.parse(input);
+
+		assertThat(result).containsOnly(
+				entry("keyString", "stringValue"),
+				entry("keyInt", 123),
+				entry("keyDouble", 123.456),
+				entry("keyBoolean", true),
+				entry("keyArray", new ArrayList<>())
+		);
+	}
+
+	@Test
+	public void parsesArrays() throws Exception {
+		JavaOnlyArray input = new JavaOnlyArray();
+		input.pushString("Hello");
+		input.pushInt(123);
+		input.pushDouble(123.456);
+		input.pushBoolean(true);
+		input.pushArray(new JavaOnlyArray());
+		input.pushMap(new JavaOnlyMap());
+		input.pushNull();
+
+		List<Object> result = ArgsParser.parseArray(input);
+		assertThat(result).containsExactly("Hello", 123, 123.456, true, new ArrayList<>(), new HashMap<>());
+	}
+}

lib/android/app/src/test/java/com/reactnativenavigation/react/NavigationModuleTest.java

@@ -1,28 +1,38 @@
 package com.reactnativenavigation.react;
 
+import com.facebook.react.bridge.JavaOnlyMap;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.NavigationActivity;
 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.controllers.CommandsHandler;
 
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.robolectric.Robolectric;
 
 import java.lang.reflect.Method;
+import java.util.HashMap;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
 
 public class NavigationModuleTest extends BaseTest {
 
 	private NavigationModule uut;
+	private ReactApplicationContext mockReactApplicationContext;
 
 	@Before
 	public void beforeEach() {
-		ReactApplicationContext reactApplicationContext = mock(ReactApplicationContext.class);
-		uut = new NavigationModule(reactApplicationContext);
+		mockReactApplicationContext = mock(ReactApplicationContext.class);
+		uut = new NavigationModule(mockReactApplicationContext);
 	}
 
 	@Test
@@ -44,4 +54,18 @@ public class NavigationModuleTest extends BaseTest {
 			}
 		}
 	}
+
+	@SuppressWarnings("unchecked")
+	@Test
+	public void parsesArgumentsIntoMap() throws Exception {
+		NavigationApplication.instance.getConfig().commandsHandler = mock(CommandsHandler.class);
+		when(mockReactApplicationContext.getCurrentActivity()).thenReturn(Robolectric.buildActivity(NavigationActivity.class).get());
+		JavaOnlyMap input = new JavaOnlyMap();
+		input.putString("key", "value");
+		uut.setRoot(input);
+		ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(HashMap.class);
+		verify(NavigationApplication.instance.getConfig().commandsHandler, times(1)).setRoot((NavigationActivity) any(), (HashMap<String, Object>) captor.capture());
+		assertThat(captor.getAllValues()).hasSize(1);
+		assertThat(captor.getValue()).isNotNull();
+	}
 }