Merge pull request #87 from ITArray/someRefactoringsAfterToleranceAdding

Some refactorings after tolerance adding

Author: dzaiats

src/main/java/net/itarray/automotion/internal/ResponsiveUIChunkValidatorBase.java

@@ -1,4 +1,4 @@
-package net.itarray.automotion.internal;
+    package net.itarray.automotion.internal;
 
 import net.itarray.automotion.internal.geometry.ConnectedIntervals;
 import net.itarray.automotion.internal.geometry.Interval;
@@ -281,9 +281,7 @@ private void validateElementsAreNotOverlapped(List<UIElement> elements) {
             UIElement first = elements.get(firstIndex);
             for (int secondIndex = firstIndex+1; secondIndex < elements.size(); secondIndex++) {
                 UIElement second = elements.get(secondIndex);
-                if (!first.notOverlaps(second, context)) {
-                    context.add("Elements are overlapped");
-                    context.draw(first);
+                if (!first.validateNotOverlappingWithElement(second, context)) {
                     break;
                 }
             }

src/main/java/net/itarray/automotion/internal/UIElement.java

@@ -7,8 +7,8 @@
 import net.itarray.automotion.internal.geometry.Rectangle;
 import net.itarray.automotion.internal.geometry.Scalar;
 import net.itarray.automotion.internal.geometry.Vector;
-import net.itarray.automotion.internal.properties.ConstantExpression;
 import net.itarray.automotion.internal.properties.Context;
+import net.itarray.automotion.internal.properties.SuccessorConditionedExpressionDescription;
 import net.itarray.automotion.tools.general.SystemHelper;
 import net.itarray.automotion.tools.helpers.TextFinder;
 import net.itarray.automotion.validation.properties.Condition;
@@ -165,44 +165,50 @@ public Scalar getBottom() {
         return getCorner().getY();
     }
 
-    public boolean overlaps(UIElement other, Context context) {
-        return Condition.lessThan(other.getRight()).isSatisfiedOn(getLeft(), context, RIGHT)  &&
-                Condition.lessThan(getRight()).isSatisfiedOn(other.getLeft(), context, RIGHT) &&
-                Condition.lessThan(other.getBottom()).isSatisfiedOn(getTop(), context, DOWN) &&
-                Condition.lessThan(getBottom()).isSatisfiedOn(other.getTop(), context, DOWN);
+    public Expression<Boolean> overlaps(UIElement other) {
+        return Expression.and(
+                Expression.and(
+                        Condition.lessThan(other.end(RIGHT)).applyTo(end(LEFT)),
+                        Condition.lessThan(end(RIGHT)).applyTo(other.end(LEFT))),
+                Expression.and(
+                        Condition.lessThan(other.end(DOWN)).applyTo(end(UP)),
+                        Condition.lessThan(end(DOWN)).applyTo(other.end(UP)))
+        );
     }
 
-    public boolean notOverlaps(UIElement other, Context context) {
-        return Condition.greaterOrEqualTo(other.getRight()).isSatisfiedOn(getLeft(), context, RIGHT)  ||
-                Condition.greaterOrEqualTo(getRight()).isSatisfiedOn(other.getLeft(), context, RIGHT) ||
-                Condition.greaterOrEqualTo(other.getBottom()).isSatisfiedOn(getTop(), context, DOWN) ||
-                Condition.greaterOrEqualTo(getBottom()).isSatisfiedOn(other.getTop(), context, DOWN);
+    public Expression<Boolean> notOverlaps(UIElement other) {
+        return Expression.or(
+                Expression.or(
+                        Condition.greaterOrEqualTo(other.end(RIGHT)).applyTo(end(LEFT)),
+                        Condition.greaterOrEqualTo(end(RIGHT)).applyTo(other.end(LEFT))),
+                Expression.or(
+                        Condition.greaterOrEqualTo(other.end(DOWN)).applyTo(end(UP)),
+                        Condition.greaterOrEqualTo(end(DOWN)).applyTo(other.end(UP)))
+        );
     }
 
-    private Scalar getOffset(Direction direction, UIElement page) {
-        return direction.signedDistance(getEnd(direction), page.getEnd(direction));
-    }
-
-    private boolean hasEqualOppositeOffsets(Direction direction, UIElement page, Context context) {
-        return equalTo(
-                new ConstantExpression<>(getOffset(direction, page)),
-                new ConstantExpression<>(getOffset(direction.opposite(), page))).evaluateIn(context, direction);
+    private <V extends MetricSpace<V>> Expression<V> offset(UIElement page, ExtendGiving<V> direction) {
+        return Expression.signedDistance(end(direction), page.end(direction), direction);
     }
 
+    @Deprecated
     private boolean hasSuccessor(Direction direction, UIElement possibleSuccessor) {
         return signedDistanceToSuccessor(direction, possibleSuccessor).isGreaterOrEqualTo(scalar(0));
     }
 
+    @Deprecated
     private Scalar signedDistanceToSuccessor(Direction direction, UIElement successor) {
         return direction.signedDistance(direction.end(rectangle), direction.begin(successor.rectangle));
     }
 
     // todo: used only in PageValidator - no tolerance yet
+    @Deprecated
     public  boolean hasRightElement(UIElement rightElement) {
         return hasSuccessor(RIGHT, rightElement);
     }
 
     // todo: used only in PageValidator - no tolerance yet
+    @Deprecated
     public boolean hasBelowElement(UIElement bottomElement) {
         return hasSuccessor(DOWN, bottomElement);
     }
@@ -230,11 +236,11 @@ private static String getShortenedText(String text) {
 
     public boolean contains(UIElement other, Context context) {
         return
-                Condition.lessOrEqualTo(other.getLeft()).isSatisfiedOn(getLeft(), context, RIGHT) &&
-                Condition.lessOrEqualTo(getRight()).isSatisfiedOn(other.getRight(), context, RIGHT) &&
-                Condition.lessOrEqualTo(other.getTop()).isSatisfiedOn(getTop(), context, DOWN) &&
-                Condition.lessOrEqualTo(getBottom()).isSatisfiedOn(other.getBottom(), context, DOWN);
-    }
+                Condition.lessOrEqualTo(other.end(LEFT)).applyTo(end(LEFT)).evaluateIn(context, RIGHT) &&
+                Condition.lessOrEqualTo(end(RIGHT)).applyTo(other.end(RIGHT)).evaluateIn(context, RIGHT) &&
+                Condition.lessOrEqualTo(other.end(UP)).applyTo(end(UP)).evaluateIn(context, DOWN) &&
+                Condition.lessOrEqualTo(end(DOWN)).applyTo(other.end(DOWN)).evaluateIn(context, DOWN);
+}
 
     public void validateLeftAlignedWith(UIElement element, Context context) {
         validateEqualEnd(LEFT, element, context);
@@ -270,6 +276,10 @@ public <V extends MetricSpace<V>> Expression<V> end(ExtendGiving<V> direction) {
         return ElementPropertyExpression.end(direction, this);
     }
 
+    public <V extends MetricSpace<V>> Expression<V> begin(ExtendGiving<V> direction) {
+        return ElementPropertyExpression.begin(direction, this);
+    }
+
     public void validateSameSize(UIElement element, Context context) {
         validateSameExtend(ORIGIN_CORNER, element, context);
     }
@@ -333,33 +343,34 @@ public void validateIsAbove(UIElement element, Condition<Scalar> condition, Cont
         validateSuccessor(DOWN, element, condition, context);
     }
 
-    public void validateSuccessor(Direction direction, UIElement toBeValidatedSuccessor, Condition<Scalar> condition, Context context) {
-        Scalar signedDistance = signedDistanceToSuccessor(direction, toBeValidatedSuccessor);
-        if (!signedDistance.satisfies(condition, context, direction)) {
-            context.add(String.format("%s element aligned not properly. Expected margin should be %s. Actual margin is %s",
-                                direction.afterName(),
-                                condition.getDescription(context, direction),
-                                signedDistance.toStringWithUnits(PIXELS)));
+    public <V extends MetricSpace<V>> void validateSuccessor(ExtendGiving<V> direction, UIElement toBeValidatedSuccessor, Condition<V> condition, Context context) {
+        Expression<V> signedDistance = Expression.signedDistance(end(direction), toBeValidatedSuccessor.begin(direction), direction);
+        Expression<Boolean> assertion = condition.applyTo(signedDistance, new SuccessorConditionedExpressionDescription<>(signedDistance, condition, direction));
+        if (!assertion.evaluateIn(context, direction)) {
+            context.add(assertion.getDescription(context, direction));
             context.draw(toBeValidatedSuccessor);
         }
     }
 
+
     public void validateOverlappingWithElement(UIElement element, Context context) {
-        if (!overlaps(element, context)) {
+        if (!overlaps(element).evaluateIn(context, DOWN)) {
             context.add(String.format("Element %s is not overlapped with element %s but should be",
                                 getQuotedName(),
                                 element.getQuotedName()));
             context.draw(element);
         }
     }
 
-    public void validateNotOverlappingWithElement(UIElement element, Context context) {
-        if (!notOverlaps(element, context)) {
+    public boolean validateNotOverlappingWithElement(UIElement element, Context context) {
+        if (!notOverlaps(element).evaluateIn(context, DOWN)) {
             context.add(String.format("Element %s is overlapped with element %s but should not",
                                 getQuotedName(),
                                 element.getQuotedName()));
             context.draw(element);
+            return false;
         }
+        return true;
     }
 
     public void validateLeftOffset(Condition condition, UIElement page, Context context) {
@@ -379,14 +390,15 @@ public void validateBottomOffset(Condition condition, UIElement page, Context co
     }
 
     public void validateOffset(Direction direction, Condition condition, UIElement page, Context context) {
-        if (!getOffset(direction, page).satisfies(condition, context, direction)) {
+        Expression<Scalar> offset = offset(page, direction);
+        if (!condition.isSatisfiedOn(offset, context, direction)) {
             context.add(
                     String.format("Expected %s offset of element %s to be %s. Actual %s offset is: %s",
                             direction.endName(),
                             getQuotedName(),
                             condition.getDescription(context, direction),
                             direction.endName(),
-                            getOffset(direction, page).toStringWithUnits(PIXELS)));
+                            offset.evaluateIn(context, direction).toStringWithUnits(PIXELS)));
         }
     }
 
@@ -400,15 +412,18 @@ public void validateCenteredOnHorizontally(UIElement page, Context context) {
 
     private void validateCentered(Direction direction, UIElement page, Context context) {
         Direction opposite = direction.opposite();
-        if (!hasEqualOppositeOffsets(direction, page, context)) {
+        Expression<Scalar> offset = offset(page, direction);
+        Expression<Scalar> oppositeOffset = offset(page, opposite);
+        Expression<Boolean> expression = equalTo(offset, oppositeOffset);
+        if (!expression.evaluateIn(context, direction)) {
             context.add(String.format("Element %s has not equal %s and %s offset. %s offset is %s, %s is %s",
                                 getQuotedName(),
                                 opposite.endName(),
                                 direction.endName(),
                                 capitalize(opposite.endName()),
-                                getOffset(opposite, page).toStringWithUnits(PIXELS),
+                                oppositeOffset.evaluateIn(context, opposite).toStringWithUnits(PIXELS),
                                 direction.endName(),
-                                getOffset(direction, page).toStringWithUnits(PIXELS)));
+                                offset.evaluateIn(context, direction).toStringWithUnits(PIXELS)));
             context.draw(this);
         }
     }

src/main/java/net/itarray/automotion/internal/geometry/Direction.java

@@ -1,12 +1,11 @@
 package net.itarray.automotion.internal.geometry;
 
-public enum Direction implements ExtendGiving<Scalar> {
-    DOWN{
-        @Override
-        public boolean beforeOrEqual(Scalar p1, Scalar p2) {
-            return p1.isLessOrEqualTo(p2);
-        }
+import java.util.function.Function;
 
+import static net.itarray.automotion.internal.geometry.Scalar.scalar;
+
+public enum Direction implements ExtendGiving<Scalar> {
+    DOWN(Vector::getY, 1) {
         public String beforeName() {
             return "Above";
         }
@@ -31,12 +30,7 @@ public String extendName() {
             return "height";
         }
     },
-    UP {
-        @Override
-        public boolean beforeOrEqual(Scalar p1, Scalar p2) {
-            return p2.isLessOrEqualTo(p1);
-        }
-
+    UP(Vector::getY, -1) {
         public String beforeName() {
             return "Below";
         }
@@ -60,13 +54,9 @@ public String beginName() {
         public String extendName() {
             return "height";
         }
-    },
-    RIGHT {
-        @Override
-        public boolean beforeOrEqual(Scalar p1, Scalar p2) {
-            return p1.isLessOrEqualTo(p2);
-        }
 
+    },
+    RIGHT(Vector::getX, 1) {
         public String beforeName() {
             return "Left";
         }
@@ -91,12 +81,7 @@ public String extendName() {
             return "width";
         }
     },
-    LEFT {
-        @Override
-        public boolean beforeOrEqual(Scalar p1, Scalar p2) {
-            return p2.isLessOrEqualTo(p1);
-        }
-
+    LEFT(Vector::getX, -1) {
         public String beforeName() {
             return "Right";
         }
@@ -120,8 +105,12 @@ public String beginName() {
         public String extendName() {
             return "width";
         }
+
     };
 
+    private final Function<Vector, Scalar> projection;
+    private final Scalar u;
+
     public abstract Direction opposite();
 
     public abstract Scalar begin(Rectangle rectangle);
@@ -146,13 +135,18 @@ public String afterName() {
 
     public abstract String extendName();
 
-    public abstract boolean beforeOrEqual(Scalar p1, Scalar p2);
-
+    @Override
     public Scalar signedDistance(Scalar p1, Scalar p2) {
-        return beforeOrEqual(p1, p2) ? distance(p1, p2) : distance(p1, p2).negated();
+        return p2.minus(p1).times(u);
+    }
+
+    @Override
+    public Function<Vector, Scalar> transform() {
+        return v -> projection.apply(v).times(u);
     }
 
-    public Scalar distance(Scalar p1, Scalar p2) {
-        return p2.minus(p1).abs();
+    Direction(Function<Vector, Scalar> projection, int u) {
+        this.projection = projection;
+        this.u = scalar(u);
     }
 }

src/main/java/net/itarray/automotion/internal/geometry/ExtendGiving.java

@@ -1,13 +1,20 @@
 package net.itarray.automotion.internal.geometry;
 
+import java.util.function.Function;
+
 public interface ExtendGiving<V extends MetricSpace<V>> {
     String beginName();
     String endName();
+    String beforeName();
+    String afterName();
     String extendName();
 
     V begin(Rectangle rectangle);
     V end(Rectangle rectangle);
     default V extend(Rectangle rectangle) {
-        return end(rectangle).minus(begin(rectangle));
+        return transform().apply(rectangle.getCorner().minus(rectangle.getOrigin()));
     }
+    V signedDistance(V p1, V p2);
+
+    Function<Vector, V> transform();
 }

src/main/java/net/itarray/automotion/internal/geometry/Rectangle.java

@@ -4,38 +4,14 @@
 import org.openqa.selenium.Point;
 import org.openqa.selenium.WebElement;
 
+import static net.itarray.automotion.internal.geometry.Direction.DOWN;
+import static net.itarray.automotion.internal.geometry.Direction.RIGHT;
+
 public class Rectangle {
     private final Vector origin;
     private final Vector corner;
 
-    public static final ExtendGiving<Vector> ORIGIN_CORNER = new ExtendGiving<Vector>() {
-        @Override
-        public String extendName() {
-            return "size";
-        }
-
-        @Override
-        public String beginName() {
-            return "top left";
-        }
-
-        @Override
-        public String endName() {
-            return "bottom right";
-        }
-
-        @Override
-        public Vector begin(Rectangle rectangle) {
-            return rectangle.getOrigin();
-        }
-
-        @Override
-        public Vector end(Rectangle rectangle) {
-            return rectangle.getCorner();
-        }
-    };
-
-
+    public static final ExtendGiving<Vector> ORIGIN_CORNER = new VectorExtendGiving(RIGHT, DOWN);
 
     public static Rectangle rectangle(WebElement webElement) {
         Point location = webElement.getLocation();
@@ -70,7 +46,7 @@ public boolean intersects(Direction direction, Rectangle other) {
     }
 
     public boolean intersects(Rectangle other) {
-        return intersects(Direction.RIGHT, other) && intersects(Direction.DOWN, other);
+        return intersects(RIGHT, other) && intersects(DOWN, other);
     }
 
     public boolean contains(Direction direction, Rectangle other) {
@@ -79,12 +55,13 @@ public boolean contains(Direction direction, Rectangle other) {
     }
 
     public boolean contains(Rectangle other) {
-        return contains(Direction.RIGHT, other) && contains(Direction.DOWN, other);
+        return contains(RIGHT, other) && contains(DOWN, other);
     }
 
     @Override
     public String toString() {
         Vector extend = corner.minus(origin);
         return String.format("[(%s,%s) - %sx%s]", origin.getX(), origin.getY(), extend.getX(), extend.getY());
     }
+
 }