calabash-android 0.4.0.pre10 → 0.4.0.pre11

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/ComparisonOperator.java

@@ -0,0 +1,54 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public enum ComparisonOperator implements UIQueryASTPredicateRelation {
+
+	LESSTHAN {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			if (areNumbers(firstValue, secondValue)) {
+				Number firstNum = (Number) firstValue;
+				Number secondNum = (Number) secondValue;
+				return firstNum.doubleValue() < secondNum.doubleValue();
+			} else {
+				return false;
+			}
+		}
+	},
+
+	LESSTHANOREQUAL {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			return EQUAL.areRelated(firstValue, secondValue) || LESSTHAN.areRelated(firstValue, secondValue);
+		}
+	},
+
+	EQUAL {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			if (firstValue == secondValue) {
+				return true;
+			}
+			return (firstValue != null) && firstValue.equals(secondValue);					
+		}
+	},
+
+	GREATERTHAN {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			if (areNumbers(firstValue, secondValue)) {
+				Number firstNum = (Number) firstValue;
+				Number secondNum = (Number) secondValue;
+				return firstNum.doubleValue() > secondNum.doubleValue();
+			} else {
+				return false;
+			}
+		}
+	},
+
+	GREATERTHANOREQUAL {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			return EQUAL.areRelated(firstValue, secondValue) || GREATERTHAN.areRelated(firstValue, secondValue);
+		}
+	};
+
+	protected boolean areNumbers(Object firstValue, Object secondValue) {
+		return (firstValue instanceof Number && secondValue instanceof Number);
+	}
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/ContainsRelation.java

@@ -0,0 +1,41 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public class ContainsRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+	
+	public ContainsRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	public boolean isCaseSensitive() { 
+		return caseSensitive;
+	}
+
+	/**
+	 * Does firstValue CONTAIN secondValue?
+	 */
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) { 
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence && secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String secondStr = secondValue.toString();
+			if (!isCaseSensitive()) {
+				firstStr = firstStr.toLowerCase();
+				secondStr = secondStr.toLowerCase();
+			}						
+			return firstStr.indexOf(secondStr) != -1;	
+		}
+		else {
+			return false;
+		}
+	}
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/EndsWithRelation.java

@@ -0,0 +1,42 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public class EndsWithRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+	
+	public EndsWithRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	public boolean isCaseSensitive() { 
+		return caseSensitive;
+	}
+
+
+	/**
+	 * Does firstValue END WITH secondValue?
+	 */
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) { 
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence && secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String secondStr = secondValue.toString();
+			if (!isCaseSensitive()) {
+				firstStr = firstStr.toLowerCase();
+				secondStr = secondStr.toLowerCase();
+			}						
+			return firstStr.endsWith(secondStr);		
+		}
+		else {
+			return false;
+		}
+	}
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/LikeRelation.java

@@ -0,0 +1,79 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class LikeRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+
+	public LikeRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	public boolean isCaseSensitive() {
+		return caseSensitive;
+	}
+
+	/**
+	 * Is firstValue LIKE secondValue? In this case secondValue is a pattern ala
+	 * 'Cou* Down' which will match a string 'Count Down'.
+	 */
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) {
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence
+				&& secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String patternStr = secondValue.toString();
+			Matcher matcher = matcherFrom(patternStr, firstStr);
+			return matcher.matches();
+		} else {
+			return false;
+		}
+	}
+
+	private Matcher matcherFrom(String patternStr, String stringToMatch) {
+		Pattern compiledPat;
+		if (isCaseSensitive()) {
+			compiledPat = Pattern.compile(translatePatternString(patternStr));
+		} else {
+			compiledPat = Pattern.compile(translatePatternString(patternStr),
+					Pattern.CASE_INSENSITIVE);
+		}
+		return compiledPat.matcher(stringToMatch);
+	}
+
+	private String translatePatternString(String patternStr) {
+
+		StringBuilder converted = new StringBuilder();
+		int beginAt = 0;
+		for (int i = 0; i < patternStr.length(); i++) {
+			char charAti = patternStr.charAt(i);
+			if (charAti == '*' || charAti == '%') {
+				String subString = patternStr.substring(beginAt, i);
+				beginAt = i + 1;
+				converted.append(Pattern.quote(subString));
+				if (charAti == '*') {
+					converted.append(".*");
+				} else if (charAti == '%') {
+					converted.append(".");
+				}
+			}
+		}
+		if (beginAt < patternStr.length()) {
+			String subString = patternStr.substring(beginAt,
+					patternStr.length());
+			converted.append(Pattern.quote(subString));
+		}
+
+		return "^" + converted.toString() + "$";
+	}
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/UIQueryASTPredicate.java

@@ -0,0 +1,147 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+import org.antlr.runtime.tree.CommonTree;
+
+import android.view.View;
+
+public class UIQueryASTPredicate implements UIQueryAST {
+
+	private final String propertyName;
+	private final UIQueryASTPredicateRelation relation;
+	private final Object valueToMatch;
+
+	public UIQueryASTPredicate(String text,
+			UIQueryASTPredicateRelation parsedRelation, Object parsedValue) {
+		this.propertyName = text;
+		this.relation = parsedRelation;
+		this.valueToMatch = parsedValue;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public List evaluateWithViews(final List inputViews,
+			final UIQueryDirection direction, final UIQueryVisibility visibility) {
+		return (List) UIQueryUtils.evaluateSyncInMainThread(new Callable() {
+
+			@SuppressWarnings("unchecked")
+			@Override
+			public Object call() throws Exception {
+				List filteredResult = new ArrayList(16);
+				for (int i = 0; i < inputViews.size(); i++) {
+					Object o = inputViews.get(i);
+
+					if (o instanceof Map) {
+						Map result = evaluateForMap((Map) o);
+						if (result != null) {
+							filteredResult.add(result);
+						}
+
+					} else {
+						Object result = evaluateForObject(o, i);
+						if (result != null) {
+							filteredResult.add(result);
+						}
+					}
+
+				}
+
+				return filteredResult;
+			}
+		});
+	}
+
+	@SuppressWarnings("rawtypes")
+	private Map evaluateForMap(Map map) {
+		if (map.containsKey(this.propertyName)) {
+			Object value = map.get(this.propertyName);
+			if (this.relation.areRelated(value, this.valueToMatch)) {
+				return map;
+			}
+		}
+		return null;
+	}
+
+	private Object evaluateForObject(Object o, int index) {
+		if (o instanceof View && this.propertyName.equals("id")) {
+			View view = (View) o;
+			String id = UIQueryUtils.getId(view);
+			if (this.relation.areRelated(id, this.valueToMatch)) {
+				return o;
+			} else {
+				// let it fall through and check via general property access
+				// in case the user actually wants to compre the real value of
+				// getId()
+			}
+		}
+
+		Method propertyAccessor = UIQueryUtils
+				.hasProperty(o, this.propertyName);
+		if (propertyAccessor == null) {
+			return null;
+		}
+		Object value = UIQueryUtils.getProperty(o, propertyAccessor);
+
+		if (this.relation.areRelated(value, this.valueToMatch)) {
+			return o;
+		} else if (this.valueToMatch instanceof String
+				&& this.relation
+						.areRelated(value.toString(), this.valueToMatch)) {
+			return o;
+		} else {
+			return null;
+		}
+	}
+
+	public static UIQueryASTPredicate newPredicateFromAST(CommonTree step) {
+		// TODO Auto-generated method stub
+		if (step.getChildCount() != 3) {
+			throw new IllegalStateException("Bad Predicate query: "+step+". Expected form {getter RELATION value}.");
+		}
+		CommonTree prop = (CommonTree) step.getChild(0);
+		CommonTree rel = (CommonTree) step.getChild(1);
+		CommonTree val = (CommonTree) step.getChild(2);
+		return new UIQueryASTPredicate(prop.getText(),
+				UIQueryASTPredicate.parseRelation(rel),
+				UIQueryUtils.parseValue(val));
+			
+	}
+
+	private static UIQueryASTPredicateRelation parseRelation(CommonTree rel) {
+		String relText = rel.getText().toUpperCase();
+		boolean caseSensitive = true;
+		final String CASE_INSENSITIVE_SPEC = "[C]";
+		if (relText.endsWith(CASE_INSENSITIVE_SPEC)) {
+			caseSensitive = false;
+			relText = relText.substring(0,relText.length() - CASE_INSENSITIVE_SPEC.length());
+		}
+		
+		if ("BEGINSWITH".equals(relText)) {
+			return new BeginsWithRelation(caseSensitive);
+		} else if ("ENDSWITH".equals(relText)) {
+			return new EndsWithRelation(caseSensitive);
+		} else if ("CONTAINS".equals(relText)) {
+			return new ContainsRelation(caseSensitive);
+		} else if ("LIKE".equals(relText)) {
+			return new LikeRelation(caseSensitive);
+		} else if ("<".equals(relText)) {
+			return ComparisonOperator.LESSTHAN;
+		} else if ("<=".equals(relText)) {
+			return ComparisonOperator.LESSTHANOREQUAL;
+		} else if ("=".equals(relText)) {
+			return ComparisonOperator.EQUAL;
+		} else if (">".equals(relText)) {
+			return ComparisonOperator.GREATERTHAN;
+		} else if (">=".equals(relText)) {
+			return ComparisonOperator.GREATERTHANOREQUAL;
+		} else {
+			throw new IllegalStateException("Unsupported Relation: " + relText);
+		}
+	}
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/UIQueryASTPredicateRelation.java

@@ -0,0 +1,5 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public interface UIQueryASTPredicateRelation {				
+	public boolean areRelated(Object firstValue, Object secondValue);
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/UIQueryASTWith.java

@@ -10,7 +10,6 @@ import java.util.concurrent.Future;
 import org.antlr.runtime.tree.CommonTree;
 
 import sh.calaba.instrumentationbackend.actions.webview.QueryHelper;
-import sh.calaba.instrumentationbackend.query.antlr.UIQueryParser;
 import android.view.View;
 import android.webkit.WebView;
 
@@ -190,31 +189,9 @@ public class UIQueryASTWith implements UIQueryAST {
 	public static UIQueryASTWith fromAST(CommonTree step) {
 		CommonTree prop = (CommonTree) step.getChild(0);
 		CommonTree val = (CommonTree) step.getChild(1);
-
-		switch (val.getType()) {
-		case UIQueryParser.STRING: {
-			String textWithPings = val.getText();
-			String text = textWithPings
-					.substring(1, textWithPings.length() - 1);
-			return new UIQueryASTWith(prop.getText(), text);
-		}
-		case UIQueryParser.INT:
-			return new UIQueryASTWith(prop.getText(), Integer.parseInt(
-					val.getText(), 10));
-		case UIQueryParser.BOOL: {
-			String text = val.getText();
-			return new UIQueryASTWith(prop.getText(),
-					Boolean.parseBoolean(text));
-		}
-		case UIQueryParser.NIL:
-			return new UIQueryASTWith(prop.getText(), null);
-
-		default:
-			throw new IllegalArgumentException("Unable to parse value type:"
-					+ val.getType() + " text " + val.getText());
-
-		}
-
+		
+		Object parsedVal = UIQueryUtils.parseValue(val);
+		return new UIQueryASTWith(prop.getText(), parsedVal);
 	}
 
 	@Override

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/ast/UIQueryUtils.java

@@ -14,16 +14,20 @@ import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.antlr.runtime.tree.CommonTree;
+
 import sh.calaba.instrumentationbackend.InstrumentationBackend;
 import sh.calaba.instrumentationbackend.actions.webview.QueryHelper;
 import sh.calaba.instrumentationbackend.query.CompletedFuture;
+import sh.calaba.instrumentationbackend.query.antlr.UIQueryParser;
 import sh.calaba.org.codehaus.jackson.map.ObjectMapper;
 import sh.calaba.org.codehaus.jackson.type.TypeReference;
 import android.content.res.Resources.NotFoundException;
 import android.view.View;
 import android.webkit.WebView;
 
-public class UIQueryUtils {
+public class UIQueryUtils {	
+	
 	@SuppressWarnings({ "unchecked", "rawtypes" })
 	public static List subviews(Object o)
 	{
@@ -206,11 +210,9 @@ public class UIQueryUtils {
 			public Object call() throws Exception {
 				List<Map<String, Object>> parsedResult;
 				try {
-					parsedResult = new ObjectMapper()
-					.readValue(
-							jsonResponse,
-							new TypeReference<List<HashMap<String, Object>>>() {
-							});
+					parsedResult = new ObjectMapper().readValue(
+									jsonResponse,
+									new TypeReference<List<HashMap<String, Object>>>() {});
 					for (Map<String,Object> data : parsedResult) {
 						Map<String,Object> rect = (Map<String, Object>) data.get("rect");
 						Map <String,Object> updatedRect = QueryHelper.translateRectToScreenCoordinates(webView, rect);
@@ -218,13 +220,52 @@ public class UIQueryUtils {
 						data.put("webView", webView);
 					}
 					return parsedResult;
-				} catch (Exception e) {
-					e.printStackTrace();
-					throw new RuntimeException(e);		
+				} catch (Exception igored) {
+					try {
+						Map resultAsMap = new ObjectMapper().readValue(
+											jsonResponse,
+											new TypeReference<HashMap>() {});
+						//This usually happens in case of error
+						//check this case
+						System.out.println(resultAsMap);
+						String errorMsg = (String) resultAsMap.get("error");
+						System.out.println(errorMsg);
+						return Collections.singletonList(resultAsMap);
+					} catch (Exception e) {
+						e.printStackTrace();
+						throw new RuntimeException(e);		
+					}
+					
+					
 				}		
 			}
 		});
 		
 	}
 
+	public static Object parseValue(CommonTree val) {
+		switch (val.getType()) {
+		case UIQueryParser.STRING: {
+			String textWithPings = val.getText();
+			String text = textWithPings
+					.substring(1, textWithPings.length() - 1);
+			return text;
+		}
+		case UIQueryParser.INT:
+			return Integer.parseInt(val.getText(), 10);
+		case UIQueryParser.BOOL: {
+			String text = val.getText();
+			return Boolean.parseBoolean(text);
+		}
+		case UIQueryParser.NIL:
+			return null;
+
+		default:
+			throw new IllegalArgumentException("Unable to parse value type:"
+					+ val.getType() + " text " + val.getText());
+
+		}
+
+	}
+
 }