Merge pull request #7062 from ibi-group/more-transfer-types

GTFS FaresV2 time limit types 2 and 3

Author: leonardehrenfried

application/src/ext-test/java/org/opentripplanner/ext/fares/impl/gtfs/TimeLimitEvaluatorTest.java

@@ -0,0 +1,67 @@
+package org.opentripplanner.ext.fares.impl.gtfs;
+
+import static java.time.Duration.ofHours;
+import static java.time.Duration.ofMinutes;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.opentripplanner.ext.fares.model.TimeLimitType.ARRIVAL_TO_ARRIVAL;
+import static org.opentripplanner.ext.fares.model.TimeLimitType.ARRIVAL_TO_DEPARTURE;
+import static org.opentripplanner.ext.fares.model.TimeLimitType.DEPARTURE_TO_ARRIVAL;
+import static org.opentripplanner.ext.fares.model.TimeLimitType.DEPARTURE_TO_DEPARTURE;
+
+import java.time.Duration;
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.opentripplanner.ext.fares.model.TimeLimit;
+import org.opentripplanner.ext.fares.model.TimeLimitType;
+import org.opentripplanner.model.plan.TestTransitLeg;
+import org.opentripplanner.model.plan.TransitLeg;
+
+class TimeLimitEvaluatorTest {
+
+  private static final TransitLeg FIRST = TestTransitLeg.of()
+    .withStartTime("10:00")
+    .withEndTime("10:05")
+    .build();
+  private static final TransitLeg SECOND = TestTransitLeg.of()
+    .withStartTime("10:10")
+    .withEndTime("10:20")
+    .build();
+
+  private static List<Arguments> withinLimitCases() {
+    return List.of(
+      Arguments.of(DEPARTURE_TO_ARRIVAL, ofMinutes(20)),
+      Arguments.of(DEPARTURE_TO_ARRIVAL, ofHours(1)),
+      Arguments.of(DEPARTURE_TO_DEPARTURE, ofMinutes(11)),
+      Arguments.of(DEPARTURE_TO_DEPARTURE, ofHours(1)),
+      Arguments.of(ARRIVAL_TO_ARRIVAL, ofMinutes(16)),
+      Arguments.of(ARRIVAL_TO_DEPARTURE, ofMinutes(5)),
+      Arguments.of(ARRIVAL_TO_DEPARTURE, ofHours(1))
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("withinLimitCases")
+  void withinLimit(TimeLimitType type, Duration duration) {
+    var limit = new TimeLimit(type, duration);
+    assertTrue(TimeLimitEvaluator.withinTimeLimit(limit, FIRST, SECOND));
+  }
+
+  private static List<Arguments> outsideLimitCases() {
+    return List.of(
+      Arguments.of(DEPARTURE_TO_ARRIVAL, ofMinutes(20).minusSeconds(20)),
+      Arguments.of(DEPARTURE_TO_DEPARTURE, ofMinutes(10).minusSeconds(1)),
+      Arguments.of(ARRIVAL_TO_ARRIVAL, ofMinutes(15).minusSeconds(1)),
+      Arguments.of(ARRIVAL_TO_DEPARTURE, ofMinutes(5).minusSeconds(1))
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("outsideLimitCases")
+  void outsideLimit(TimeLimitType type, Duration duration) {
+    var limit = new TimeLimit(type, duration);
+    assertFalse(TimeLimitEvaluator.withinTimeLimit(limit, FIRST, SECOND));
+  }
+}

application/src/ext/java/org/opentripplanner/ext/fares/impl/gtfs/TimeLimitEvaluator.java

@@ -16,6 +16,8 @@ static boolean withinTimeLimit(TimeLimit limit, TransitLeg from, TransitLeg to)
       switch (limit.type()) {
         case DEPARTURE_TO_DEPARTURE -> Duration.between(from.startTime(), to.startTime());
         case DEPARTURE_TO_ARRIVAL -> Duration.between(from.startTime(), to.endTime());
+        case ARRIVAL_TO_ARRIVAL -> Duration.between(from.endTime(), to.endTime());
+        case ARRIVAL_TO_DEPARTURE -> Duration.between(from.endTime(), to.startTime());
       };
 
     return duration.compareTo(limit.duration()) <= 0;

application/src/ext/java/org/opentripplanner/ext/fares/model/FareTransferType.java

@@ -14,4 +14,14 @@ public enum TimeLimitType {
    * the next one.
    */
   DEPARTURE_TO_DEPARTURE,
+  /**
+   * The duration is to be computed from the arrival time of the current leg to the departure time of
+   * the next one.
+   */
+  ARRIVAL_TO_DEPARTURE,
+  /**
+   * The duration is to be computed from the arrival time of the current leg to the arrival time of
+   * the next one.
+   */
+  ARRIVAL_TO_ARRIVAL,
 }

application/src/ext/java/org/opentripplanner/ext/fares/model/TimeLimitType.java

@@ -67,9 +67,8 @@ static TimeLimitType mapLimitType(int durationLimitType) {
     return switch (durationLimitType) {
       case 0 -> TimeLimitType.DEPARTURE_TO_ARRIVAL;
       case 1 -> TimeLimitType.DEPARTURE_TO_DEPARTURE;
-      case 2, 3 -> throw new IllegalArgumentException(
-        "Duration limit type %s not implemented.".formatted(durationLimitType)
-      );
+      case 2 -> TimeLimitType.ARRIVAL_TO_DEPARTURE;
+      case 3 -> TimeLimitType.ARRIVAL_TO_ARRIVAL;
       default -> throw new IllegalArgumentException("Valid duration limit type must be provided.");
     };
   }

application/src/main/java/org/opentripplanner/gtfs/mapping/FareTransferRuleMapper.java

@@ -0,0 +1,111 @@
+package org.opentripplanner.model.plan;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+import java.util.Set;
+import org.apache.commons.lang3.NotImplementedException;
+import org.jetbrains.annotations.Nullable;
+import org.locationtech.jts.geom.LineString;
+import org.opentripplanner.model.fare.FareOffer;
+import org.opentripplanner.model.plan.leg.LegCallTime;
+import org.opentripplanner.routing.alertpatch.TransitAlert;
+import org.opentripplanner.transit.model.basic.TransitMode;
+
+/**
+ * Many methods in this class throw {@link NotImplementedException}. Please implement them when
+ * you need them.
+ */
+public class TestTransitLeg implements TransitLeg {
+
+  private final ZonedDateTime startTime;
+  private final ZonedDateTime endTime;
+
+  public TestTransitLeg(TestTransitLegBuilder builder) {
+    this.startTime = builder.startTime;
+    this.endTime = builder.endTime;
+  }
+
+  @Override
+  public TransitMode mode() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public TransitLeg decorateWithAlerts(Set<TransitAlert> alerts) {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public TransitLeg decorateWithFareOffers(List<FareOffer> fares) {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public LegCallTime start() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public LegCallTime end() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public ZonedDateTime startTime() {
+    return startTime;
+  }
+
+  @Override
+  public ZonedDateTime endTime() {
+    return endTime;
+  }
+
+  @Override
+  public double distanceMeters() {
+    return 0;
+  }
+
+  @Override
+  public Place from() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public Place to() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public @Nullable LineString legGeometry() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public Set<TransitAlert> listTransitAlerts() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public @Nullable Emission emissionPerPerson() {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public @Nullable Leg withEmissionPerPerson(Emission emissionPerPerson) {
+    throw new NotImplementedException();
+  }
+
+  @Override
+  public int generalizedCost() {
+    return 0;
+  }
+
+  @Override
+  public List<FareOffer> fareOffers() {
+    return List.of();
+  }
+
+  public static TestTransitLegBuilder of() {
+    return new TestTransitLegBuilder();
+  }
+}

application/src/test-fixtures/java/org/opentripplanner/model/plan/TestTransitLeg.java

@@ -0,0 +1,32 @@
+package org.opentripplanner.model.plan;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZonedDateTime;
+import org.opentripplanner._support.time.ZoneIds;
+
+public class TestTransitLegBuilder {
+
+  private static final LocalDate DATE = LocalDate.parse("2025-11-17");
+  private static final ZonedDateTime TIME = LocalTime.parse("12:00")
+    .atDate(DATE)
+    .atZone(ZoneIds.UTC);
+  ZonedDateTime startTime = TIME;
+  ZonedDateTime endTime = TIME.plusHours(1);
+
+  public TestTransitLegBuilder withStartTime(String startTime) {
+    var time = LocalTime.parse(startTime);
+    this.startTime = DATE.atTime(time).atZone(ZoneIds.UTC);
+    return this;
+  }
+
+  public TestTransitLegBuilder withEndTime(String endTime) {
+    var time = LocalTime.parse(endTime);
+    this.endTime = DATE.atTime(time).atZone(ZoneIds.UTC);
+    return this;
+  }
+
+  public TestTransitLeg build() {
+    return new TestTransitLeg(this);
+  }
+}

application/src/test-fixtures/java/org/opentripplanner/model/plan/TestTransitLegBuilder.java

@@ -68,6 +68,8 @@ void timeLimit() {
   void limitType() {
     assertEquals(TimeLimitType.DEPARTURE_TO_ARRIVAL, FareTransferRuleMapper.mapLimitType(0));
     assertEquals(TimeLimitType.DEPARTURE_TO_DEPARTURE, FareTransferRuleMapper.mapLimitType(1));
+    assertEquals(TimeLimitType.ARRIVAL_TO_DEPARTURE, FareTransferRuleMapper.mapLimitType(2));
+    assertEquals(TimeLimitType.ARRIVAL_TO_ARRIVAL, FareTransferRuleMapper.mapLimitType(3));
   }
 
   @Test