Made code compatible with java 7

build.gradle

@@ -4,7 +4,7 @@ version '1.0.0'
 apply plugin: 'java'
 apply plugin: 'idea'
 
-sourceCompatibility = 1.8
+sourceCompatibility = 1.7
 
 repositories {
     mavenCentral()

src/main/java/org/pjesus/ruletree/condition/factory/ConditionFactory.java

@@ -1,14 +1,18 @@
 package org.pjesus.ruletree.condition.factory;
 
-import com.google.inject.Guice;
-import com.google.inject.Injector;
+import java.util.Collection;
+import java.util.Set;
+
+import javax.inject.Inject;
+
 import org.pjesus.ruletree.RuleTreeModule;
 import org.pjesus.ruletree.condition.AbstractCondition;
 import org.pjesus.ruletree.condition.annotation.Condition;
+import org.pjesus.ruletree.utils.CollectionUtils;
 import org.reflections.Reflections;
 
-import javax.inject.Inject;
-import java.util.Set;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
 
 public class ConditionFactory {
   private final Reflections reflections;
@@ -18,13 +22,16 @@ public ConditionFactory(Reflections reflections) {
     this.reflections = reflections;
   }
 
-  public AbstractCondition create(String conditionName) {
+  public AbstractCondition create(final String conditionName) {
     Set<Class<?>> conditionClasses = this.reflections.getTypesAnnotatedWith(Condition.class);
-    Class<?> conditionClass = conditionClasses.stream()
-      .filter(c -> c.getAnnotation(Condition.class).value().equals(conditionName))
-      .findFirst()
-      .orElse(AbstractCondition.class);
-
+    Collection<Class<?>> filteredConditionClasses = CollectionUtils.filter(conditionClasses, new CollectionUtils.FilterCallback() {
+
+		@Override
+		public boolean filter(Object object) {
+			return ((Class<?>) object).getAnnotation(Condition.class).value().equals(conditionName);
+		}
+	});
+    Class<?> conditionClass = CollectionUtils.getFirstOrDefault(filteredConditionClasses, AbstractCondition.class);
     Injector injector = Guice.createInjector(new RuleTreeModule());
     return (AbstractCondition) injector.getInstance(conditionClass);
   }

src/main/java/org/pjesus/ruletree/selector/DataSelector.java

@@ -9,6 +9,7 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+@SuppressWarnings({"rawtypes", "unchecked"})
 public class DataSelector {
 
   public Object select(Object data, String dataPath) throws Exception {

src/main/java/org/pjesus/ruletree/utils/CollectionUtils.java

@@ -0,0 +1,84 @@
+package org.pjesus.ruletree.utils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class CollectionUtils {
+
+	public static boolean isEmpty(Collection<?> list) {
+		return list == null || list.size() == 0;
+	}
+
+	public static <T> T getFirstOrDefault(Collection<T> list, T defaultItem) {
+		if(isEmpty(list))
+			return defaultItem;
+		return list.iterator().next();
+	}
+
+	public static Collection<Object> map(Collection<?> list, MapCallback callback) {
+		List<Object> mapList = new ArrayList<>();
+		for(Object item : list)
+			mapList.add(callback.map(item));
+		return mapList;
+	}
+
+	public static Collection<Double> mapToDouble(Collection<?> list, MapCallback callback) {
+		List<Double> mapList = new ArrayList<>();
+		for(Object item : list)
+			mapList.add((Double) callback.map(item));
+		return mapList;
+	}
+
+	public static Double sum(Collection<Number> list) {
+		Double sum = 0.0;
+		for(Number number : list) {
+			sum += number.doubleValue();
+		}
+		return sum;
+	}
+
+	public static <T> Collection<T> filter(Collection<T> list, FilterCallback callback) {
+		List<T> filteredList = new ArrayList<>();
+		for(T item : list)
+			if(callback.filter(item))
+				filteredList.add(item);
+		return filteredList;
+	}
+
+	public static <T> boolean noneMatch(Collection<T> list, MatchCallback callback) {
+		for(T item : list)
+			if(callback.match(item))
+				return false;
+		return true;
+	}
+
+	public static <T> boolean anyMatch(Collection<T> list, MatchCallback callback) {
+		for(T item : list)
+			if(callback.match(item))
+				return true;
+		return false;
+	}
+
+	public static <T> boolean allMatch(Collection<T> list, MatchCallback callback) {
+		for(T item : list)
+			if(!callback.match(item))
+				return false;
+		return true;
+	}
+
+	public interface MapCallback {
+
+		Object map(Object item);
+	}
+
+	public interface FilterCallback {
+
+		boolean filter(Object item);
+	}
+
+	public interface MatchCallback {
+
+		boolean match(Object item);
+	}
+}

src/main/java/org/pjesus/ruletree/utils/MapUtils.java

@@ -0,0 +1,23 @@
+package org.pjesus.ruletree.utils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MapUtils {
+
+	public static Map<String, Object> create(Object... items) throws RuntimeException {
+		Map<String, Object> map = new HashMap<>();
+		if(items == null || items.length == 0)
+			return map;
+		if(items.length % 2 != 0)
+			throw new RuntimeException("Even number of items needed");
+
+		for(int i=0; i<items.length; i+=2) {
+			String key = (String) items[i];
+			Object value = items[i+1];
+			map.put(key, value);
+		}
+
+		return map;
+	}
+}

src/main/java/org/pjesus/ruletree/validator/AndValidator.java

@@ -2,6 +2,7 @@
 
 import org.pjesus.ruletree.RuleTree;
 import org.pjesus.ruletree.rule.Rule;
+import org.pjesus.ruletree.utils.CollectionUtils;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -15,16 +16,22 @@ public AndValidator(RuleTree ruleTree) {
     this.ruleTree = ruleTree;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
-  public Boolean validate(Rule rule, Object data) {
+  public Boolean validate(Rule rule, final Object data) {
     Map<String, Object> attributes = rule.getAttributes();
     List<Map<String, Object>> ruleConfigs = (List<Map<String, Object>>) attributes.get("rules");
-
+    
     try {
-      return ruleConfigs.stream()
-        .allMatch(ruleConfig -> this.ruleTree.validate(ruleConfig, data));
-    } catch (Exception e) {
-      return false;
-    }
+		return CollectionUtils.allMatch(ruleConfigs, new CollectionUtils.MatchCallback() {
+
+			@Override
+			public boolean match(Object ruleConfig) {
+				return ruleTree.validate(((Map<String, Object>) ruleConfig), data);
+			}
+		});
+    } catch(Exception e) {
+		return false;
+	}
   }
 }

src/main/java/org/pjesus/ruletree/validator/EqualsValidator.java

@@ -1,11 +1,11 @@
 package org.pjesus.ruletree.validator;
 
-import org.pjesus.ruletree.parser.Parser;
-import org.pjesus.ruletree.rule.Rule;
-import org.pjesus.ruletree.selector.DataSelector;
+import java.util.Map;
 
 import javax.inject.Inject;
-import java.util.Map;
+
+import org.pjesus.ruletree.rule.Rule;
+import org.pjesus.ruletree.selector.DataSelector;
 
 public class EqualsValidator implements Validator {
   private final DataSelector dataSelector;

src/main/java/org/pjesus/ruletree/validator/EveryValidator.java

@@ -3,6 +3,7 @@
 import org.pjesus.ruletree.RuleTree;
 import org.pjesus.ruletree.rule.Rule;
 import org.pjesus.ruletree.selector.DataSelector;
+import org.pjesus.ruletree.utils.CollectionUtils;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -18,16 +19,22 @@ public EveryValidator(RuleTree ruleTree, DataSelector dataSelector) {
     this.dataSelector = dataSelector;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public Boolean validate(Rule rule, Object data) {
     Map<String, Object> attributes = rule.getAttributes();
     String dataPath = (String) attributes.get("data");
-    Map<String, Object> ruleConfig = (Map<String, Object>) attributes.get("rule");
+    final Map<String, Object> ruleConfig = (Map<String, Object>) attributes.get("rule");
 
     try {
       List<?> selectedDataList = (List<?>) this.dataSelector.select(data, dataPath);
-      return selectedDataList.stream()
-        .allMatch(dataItem -> this.ruleTree.validate(ruleConfig, dataItem));
+      return CollectionUtils.allMatch(selectedDataList, new CollectionUtils.MatchCallback() {
+
+		@Override
+		public boolean match(Object dataItem) {
+			return ruleTree.validate(ruleConfig, dataItem);
+		}
+      });
     } catch (Exception e) {
       return false;
     }

src/main/java/org/pjesus/ruletree/validator/InValidator.java

@@ -2,6 +2,7 @@
 
 import org.pjesus.ruletree.rule.Rule;
 import org.pjesus.ruletree.selector.DataSelector;
+import org.pjesus.ruletree.utils.CollectionUtils;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -22,9 +23,14 @@ public Boolean validate(Rule rule, Object data) {
     List<?> values = (List<?>) attributes.get("value");
 
     try {
-      Object selectedData = this.dataSelector.select(data, dataPath);
-      return values.stream()
-        .anyMatch(value -> value.equals(selectedData));
+      final Object selectedData = this.dataSelector.select(data, dataPath);
+      return CollectionUtils.anyMatch(values, new CollectionUtils.MatchCallback() {
+
+		@Override
+		public boolean match(Object value) {
+			return value.equals(selectedData);
+		}
+      });
     } catch (Exception e) {
       return false;
     }

src/main/java/org/pjesus/ruletree/validator/NotInValidator.java

@@ -2,6 +2,7 @@
 
 import org.pjesus.ruletree.rule.Rule;
 import org.pjesus.ruletree.selector.DataSelector;
+import org.pjesus.ruletree.utils.CollectionUtils;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -22,9 +23,14 @@ public Boolean validate(Rule rule, Object data) {
     List<?> values = (List<?>) attributes.get("value");
 
     try {
-      Object selectedData = this.dataSelector.select(data, dataPath);
-      return values.stream()
-        .noneMatch(value -> value.equals(selectedData));
+      final Object selectedData = this.dataSelector.select(data, dataPath);
+      return CollectionUtils.noneMatch(values, new CollectionUtils.MatchCallback() {
+
+		@Override
+		public boolean match(Object value) {
+			return value.equals(selectedData);
+		}
+      });
     } catch (Exception e) {
       return false;
     }

src/main/java/org/pjesus/ruletree/validator/OrValidator.java

@@ -2,6 +2,7 @@
 
 import org.pjesus.ruletree.RuleTree;
 import org.pjesus.ruletree.rule.Rule;
+import org.pjesus.ruletree.utils.CollectionUtils;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -15,14 +16,20 @@ public OrValidator(RuleTree ruleTree) {
     this.ruleTree = ruleTree;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
-  public Boolean validate(Rule rule, Object data) {
+  public Boolean validate(Rule rule, final Object data) {
     Map<String, Object> attributes = rule.getAttributes();
     List<Map<String, Object>> ruleConfigs = (List<Map<String, Object>>) attributes.get("rules");
 
     try {
-      return ruleConfigs.stream()
-        .anyMatch(ruleConfig -> this.ruleTree.validate(ruleConfig, data));
+      return CollectionUtils.anyMatch(ruleConfigs, new CollectionUtils.MatchCallback() {
+
+  		@Override
+  		public boolean match(Object ruleConfig) {
+  			return ruleTree.validate((Map<String, Object>) ruleConfig, data);
+  		}
+      });
     } catch (Exception e) {
       return false;
     }

src/main/java/org/pjesus/ruletree/validator/SomeValidator.java

@@ -3,6 +3,7 @@
 import org.pjesus.ruletree.RuleTree;
 import org.pjesus.ruletree.rule.Rule;
 import org.pjesus.ruletree.selector.DataSelector;
+import org.pjesus.ruletree.utils.CollectionUtils;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -18,16 +19,22 @@ public SomeValidator(RuleTree ruleTree, DataSelector dataSelector) {
     this.dataSelector = dataSelector;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public Boolean validate(Rule rule, Object data) {
     Map<String, Object> attributes = rule.getAttributes();
     String dataPath = (String) attributes.get("data");
-    Map<String, Object> ruleConfig = (Map<String, Object>) attributes.get("rule");
+    final Map<String, Object> ruleConfig = (Map<String, Object>) attributes.get("rule");
 
     try {
       List<?> selectedDataList = (List<?>) this.dataSelector.select(data, dataPath);
-      return selectedDataList.stream()
-        .anyMatch(dataItem -> this.ruleTree.validate(ruleConfig, dataItem));
+      return CollectionUtils.anyMatch(selectedDataList, new CollectionUtils.MatchCallback() {
+
+  		@Override
+  		public boolean match(Object dataItem) {
+  			return ruleTree.validate(ruleConfig, dataItem);
+  		}
+      });
     } catch (Exception e) {
       return false;
     }