@transportme/load-ptv-gtfs 1.0.8 → 1.1.0

package/lib/gtfs-parser/GTFSRoute.mjs

@@ -57,7 +57,7 @@ export default class GTFSRoute {
    */
   static create(data, mode) {
     let { routeGTFSID } = data
-    let routeTypes = [ MetroGTFSRoute, SmartrakGTFSRoute, GTFSRoute ]
+    let routeTypes = [ NewMetroGTFSRoute, MetroGTFSRoute, SmartrakGTFSRoute, GTFSRoute ]
     for (let type of routeTypes) {
       if (type.canProcess(routeGTFSID, mode)) return new type(data)
     }
@@ -87,7 +87,7 @@ class SmartrakGTFSRoute extends GTFSRoute {
 }
 
 /**
- * Used to represent a Metro train route
+ * Used to represent a Metro train route on the new data
  *
  * Used for a technicality where the route name (eg Pakenham) is stored in the route number instead.
  */
@@ -103,4 +103,22 @@ class MetroGTFSRoute extends GTFSRoute {
     return mode === TRANSIT_MODES.metroTrain
   }
 
+}
+
+/**
+ * Used to represent a Metro train route on the new data
+ *
+ * Required to parse the route ID which is of a slightly different format
+ */
+class NewMetroGTFSRoute extends MetroGTFSRoute {
+
+  static canProcess(routeGTFSID, mode) {
+    return super.canProcess(routeGTFSID, mode) && routeGTFSID.includes(':vic:')
+  }
+
+  parseRouteID(routeGTFSID) {
+    let [ _, routeNumber ] = routeGTFSID.match(/02\-(\w{3})/)
+    return `2-${routeNumber}`
+  }  
+
 }

package/lib/gtfs-parser/GTFSStop.mjs

@@ -182,7 +182,7 @@ export class GTFSStop {
   }
 
   static create(data, suburbs) {
-    let types = [ GTFSPlatformStop, GTFSStop ]
+    let types = [ GTFSRRBStop, GTFSPlatformStop, GTFSStop ]
     for (let type of types) {
       if (type.canProcess(data)) return new type(data, suburbs)
     }
@@ -209,4 +209,18 @@ export class GTFSPlatformStop extends GTFSStop {
     return data.platform && data.platform.length
   }
 
+}
+
+export class GTFSRRBStop extends GTFSPlatformStop {
+
+  constructor(data, suburbs) {
+    data.stopName = data.stopName.replace('Rail Replacement Bus Stop', 'Railway Station')
+    super(data, suburbs)
+    this.platform = 'RRB'
+  }
+
+  static canProcess(data) {
+    return super.canProcess(data) && data.platform === 'R-Bus'
+  }
+
 }

package/lib/gtfs-parser/GTFSTrip.mjs

@@ -136,9 +136,10 @@ export class SmartrakTrip extends GTFSTrip {
 /**
  * Used to represent a Metro train trip.
  * 
- * Trip IDs are of the form 02-ROUTE--ROUTE_VARIANT-ROSTER-TDN. Note that TDNs are alphanumeric
+ * Trip IDs are of the form 02-ROUTE--ROUTE_VARIANT-CALENDAR-TDN. Note that TDNs are alphanumeric
  * 
  * Example: 02-BEG--58-T5_n4-3651
+ * RRB Example: 02-SUY--13-T2-BS000
  */
 export class MetroTrip extends GTFSTrip {
 
@@ -147,18 +148,21 @@ export class MetroTrip extends GTFSTrip {
   constructor(data) {
     super(data)
 
-    let runID = data.id.match(/^02-\w{3}-.*-(\w\d{3})$/)
+    let runID = data.id.match(/^02-\w{3}-.*-(\w{1,2}\d{3})$/)
     this.#runID = runID[1]
   }
 
   static canProcess(data, mode) {
-    return mode === TRANSIT_MODES.metroTrain && data.id.match(/^02-\w{3}-.*-(\w\d{3})$/)
+    return mode === TRANSIT_MODES.metroTrain && data.id.match(/^02-\w{3}-.*-(\w{1,2}\d{3})$/)
   }
 
   getTripData() {
+    let runID = this.getRunID()
+
     return {
       ...super.getTripData(),
-      runID: this.getRunID()
+      runID,
+      isRailReplacementBus: runID.length === 5 && runID[0] === 'B'
     }
   }
 

package/lib/post-processing/set-route-stops.mjs

@@ -63,11 +63,19 @@ export default async function setRouteStops(database) {
 
       if (routeData.mode === TRANSIT_MODES.metroTrain) {
         let currentDir = stopsByService[routeGTFSID][gtfsDirection].directionName
-        if (currentDir.includes('Flinders Street') || currentDir.includes('Town Hall')) {
-          stopsByService[routeGTFSID][gtfsDirection].directionName = 'City'
+        let isUp = currentDir.includes('Flinders Street') || currentDir.includes('Town Hall')
+
+        let directionName = stopsByService[routeGTFSID][gtfsDirection].directionName
+
+        if (routeData.routeName === 'Stony Point') {
+          isUp = currentDir.includes('Frankston')
+          directionName = directionName.slice(0, -16)
         } else {
-          stopsByService[routeGTFSID][gtfsDirection].directionName = currentDir.slice(0, -16)
+          directionName = isUp ? 'City' :  routeData.routeName
         }
+
+        stopsByService[routeGTFSID][gtfsDirection].directionName = directionName
+        stopsByService[routeGTFSID][gtfsDirection].trainDirection = isUp ? 'Up' : 'Down'
       }
     }
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transportme/load-ptv-gtfs",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "",
   "main": "index.mjs",
   "scripts": {

package/test/gtfs-trip-loader.test.mjs

@@ -21,9 +21,6 @@ const stopsFile = path.join(__dirname, 'sample-data', 'trips', 'stops.txt')
 const stopTimesFile = path.join(__dirname, 'sample-data', 'trips', 'stop_times.txt')
 const tripsFile = path.join(__dirname, 'sample-data', 'trips', 'trips.txt')
 
-const newStopTimesFile = path.join(__dirname, 'sample-data', 'trips', 'stop_times_new.txt')
-const newTripsFile = path.join(__dirname, 'sample-data', 'trips', 'trips_new.txt')
-
 describe('The TripLoader class', () => {
   it('Should process the trip and add it to the database', async () => {
     let database = new LokiDatabaseConnection('test-db')
@@ -112,31 +109,4 @@ describe('The TripLoader class', () => {
 
     expect(shapeIDMap['2-ALM-vpt-1.1.R']).to.equal('2-ALM')
   })
-
-  it('It should accept trip IDs in the new format and extract the TDN from there', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let stops = await database.createCollection('stops')
-    let routes = await database.createCollection('routes')
-    let trips = await database.createCollection('gtfs timetables')
-
-    let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
-    await stopLoader.loadStops()
-
-    let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
-    await routeLoader.loadRoutes()
-
-    let routeIDMap = routeLoader.getRouteIDMap()
-
-    let tripLoader = new TripLoader({
-      tripsFile: newTripsFile, stopTimesFile: newStopTimesFile,
-      calendarFile, calendarDatesFile
-    }, TRANSIT_MODES.metroTrain, database)
-    
-    await tripLoader.loadTrips({ routeIDMap })
-
-    let trip = await trips.findDocument({ tripID: '02-ALM--1-T2-2302' })
-
-    expect(trip).to.not.be.null
-    expect(trip.runID).to.equal('2302')
-  })
 })

package/test/merge-stops-full.test.mjs

@@ -0,0 +1,99 @@
+import { expect } from 'chai'
+import path from 'path'
+import url from 'url'
+import { TRANSIT_MODES } from '../lib/constants.mjs'
+import { LokiDatabaseConnection } from '@transportme/database'
+import StopsLoader from '../lib/loader/StopsLoader.mjs'
+import RouteLoader from '../lib/loader/RouteLoader.mjs'
+import TripLoader from '../lib/loader/TripLoader.mjs'
+import ShapeLoader from '../lib/loader/ShapeLoader.mjs'
+import setRouteStops from '../lib/post-processing/set-route-stops.mjs'
+import suburbs from './sample-data/suburbs.json' with { type: 'json' }
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const routesFile = path.join(__dirname, 'sample-data', 'routes', 'metro_lines.txt')
+const agencyFile = path.join(__dirname, 'sample-data', 'routes', 'agency.txt')
+
+const calendarFile = path.join(__dirname, 'sample-data', 'calendar', 'calendar.txt')
+const calendarDatesFile = path.join(__dirname, 'sample-data', 'calendar', 'calendar_dates.txt')
+
+const stopsFile = path.join(__dirname, 'sample-data', 'merge', 'stops.txt')
+const stopTimesFile = path.join(__dirname, 'sample-data', 'merge', 'stop_times.txt')
+const tripsFile = path.join(__dirname, 'sample-data', 'merge', 'trips.txt')
+const shapeFile = path.join(__dirname, 'sample-data', 'merge', 'shapes.txt')
+
+let database = new LokiDatabaseConnection('test-db')
+let stops = await database.createCollection('stops')
+let routes = await database.createCollection('routes')
+let trips = await database.createCollection('gtfs timetables')
+
+let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+await stopLoader.loadStops()
+
+let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+await routeLoader.loadRoutes()
+
+let routeIDMap = routeLoader.getRouteIDMap()
+
+let tripLoader = new TripLoader({
+  tripsFile, stopTimesFile,
+  calendarFile, calendarDatesFile
+}, TRANSIT_MODES.metroTrain, database)
+
+await tripLoader.loadTrips({ routeIDMap })
+let shapeIDMap = tripLoader.getShapeIDMap()
+
+let shapeLoader = new ShapeLoader(shapeFile, database)
+
+await shapeLoader.loadShapes({ shapeIDMap })
+
+await setRouteStops(database)
+
+describe('The GTFS Route stop merger', () => {
+  describe('When processing Metro routes', () => {
+    it('Should set Up trips to be City-bound', async () => {
+      let pakenhamRoute = await routes.findDocument({ routeGTFSID: '2-PKM' })
+      expect(pakenhamRoute).to.not.be.null
+      
+      let city = pakenhamRoute.directions.find(dir => dir.directionName === 'City')
+      expect(city).to.not.be.undefined
+      expect(city.stops[0].stopName).to.equal('East Pakenham Railway Station')
+      expect(city.stops[city.stops.length - 2].stopName).to.equal('Southern Cross Railway Station')
+      expect(city.stops[city.stops.length - 1].stopName).to.equal('Flinders Street Railway Station')
+    })
+
+    it('Should set Down trips to the name of the route', async () => {
+      let pakenhamRoute = await routes.findDocument({ routeGTFSID: '2-PKM' })
+      expect(pakenhamRoute).to.not.be.null
+
+      let pakenham = pakenhamRoute.directions.find(dir => dir.directionName !== 'City')
+      expect(pakenham).to.not.be.undefined
+      expect(pakenham.directionName).to.equal('Pakenham')
+      expect(pakenham.stops[0].stopName).to.equal('Flinders Street Railway Station')
+      expect(pakenham.stops[pakenham.stops.length - 2].stopName).to.equal('Pakenham Railway Station')
+      expect(pakenham.stops[pakenham.stops.length - 1].stopName).to.equal('East Pakenham Railway Station')
+    })
+
+    it('Should set Stony Point to Frankston trips as Up', async () => {
+      let stonyPointRoute = await routes.findDocument({ routeGTFSID: '2-STY' })
+      expect(stonyPointRoute).to.not.be.null
+      
+      let frankston = stonyPointRoute.directions.find(dir => dir.directionName === 'Frankston')
+      expect(frankston).to.not.be.undefined
+      expect(frankston.stops[0].stopName).to.equal('Stony Point Railway Station')
+      expect(frankston.stops[frankston.stops.length - 1].stopName).to.equal('Frankston Railway Station')
+    })
+
+    it('Should set Stony Point trips as Down', async () => {
+      let stonyPointRoute = await routes.findDocument({ routeGTFSID: '2-STY' })
+      expect(stonyPointRoute).to.not.be.null
+
+      let stonyPoint = stonyPointRoute.directions.find(dir => dir.directionName === 'Stony Point')
+      expect(stonyPoint).to.not.be.undefined
+      expect(stonyPoint.stops[0].stopName).to.equal('Frankston Railway Station')
+      expect(stonyPoint.stops[stonyPoint.stops.length - 1].stopName).to.equal('Stony Point Railway Station')
+    })
+  })
+})

package/test/new-metro-loader-test.test.mjs

@@ -0,0 +1,165 @@
+import { LokiDatabaseConnection } from '@transportme/database'
+import StopsLoader from '../lib/loader/StopsLoader.mjs'
+import { TRANSIT_MODES } from '../lib/constants.mjs'
+import path from 'path'
+import url from 'url'
+import { expect } from 'chai'
+import suburbs from './sample-data/suburbs.json' with { type: 'json' }
+import RouteLoader from '../lib/loader/RouteLoader.mjs'
+import TripLoader from '../lib/loader/TripLoader.mjs'
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const agencyFile = path.join(__dirname, 'sample-data', 'routes', 'agency.txt')
+
+const calendarFile = path.join(__dirname, 'sample-data', 'new-metro', 'calendar.txt')
+const calendarDatesFile = path.join(__dirname, 'sample-data', 'new-metro', 'calendar_dates.txt')
+
+const routesFile = path.join(__dirname, 'sample-data', 'new-metro', 'routes.txt')
+
+const stopTimesFile = path.join(__dirname, 'sample-data', 'new-metro', 'stop_times.txt')
+const tripsFile = path.join(__dirname, 'sample-data', 'new-metro', 'trips.txt')
+const stopsFile = path.join(__dirname, 'sample-data', 'new-metro', 'stops.txt')
+
+const simpleStopsFile = path.join(__dirname, 'sample-data', 'new-metro', 'simple_stop_test.txt')
+
+describe('The GTFS Loaders with the new Metro data', () => {
+  describe('The stop loader', () => {
+    it('Should process the stops and add them to the database', async () => {
+      let database = new LokiDatabaseConnection('test-db')
+      let stops = await database.createCollection('stops')
+
+      let loader = new StopsLoader(simpleStopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+      await loader.loadStops()
+
+      let stop = await stops.findDocument({
+        'stopName': 'Camberwell Railway Station'
+      })
+
+      expect(stop).to.not.be.null
+    })
+
+    it('Should label the individual platforms with their platform numbers', async () => {
+      let database = new LokiDatabaseConnection('test-db')
+      let stops = await database.createCollection('stops')
+
+      let loader = new StopsLoader(simpleStopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+      await loader.loadStops()
+
+      let stop = await stops.findDocument({
+        'stopName': 'Camberwell Railway Station'
+      })
+
+      let platformIDs = ["11207", "11208", "11209"]
+      let platforms = platformIDs.map(id => stop.bays.find(bay => bay.stopGTFSID === id))
+
+      for (let i = 0; i < platformIDs.length; i++) {
+        let platform = platforms[i]
+        expect(platform).to.not.be.undefined
+        expect(platforms[i].platform).to.equal((i + 1).toString())
+      }
+    })
+  })
+
+  describe('The route loader', () => {
+    it('Should convert the updated route ID format to the legacy format', async () => {
+      let database = new LokiDatabaseConnection('test-db')
+      let routes = await database.createCollection('routes')
+
+      let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+      await routeLoader.loadRoutes()
+
+      let pakenham = await routes.findDocument({ routeName: 'Pakenham' })
+
+      expect(pakenham).to.exist
+      expect(pakenham.routeGTFSID).to.equal('2-PKM')
+    })
+  })
+
+  describe('The trip loader', () => {
+    it('It should accept trip IDs in the new format and extract the TDN from there', async () => {
+      let database = new LokiDatabaseConnection('test-db')
+      let stops = await database.createCollection('stops')
+      let routes = await database.createCollection('routes')
+      let trips = await database.createCollection('gtfs timetables')
+
+      let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+      await stopLoader.loadStops()
+
+      let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+      await routeLoader.loadRoutes()
+
+      let routeIDMap = routeLoader.getRouteIDMap()
+
+      let tripLoader = new TripLoader({
+        tripsFile, stopTimesFile,
+        calendarFile, calendarDatesFile
+      }, TRANSIT_MODES.metroTrain, database)
+
+      await tripLoader.loadTrips({ routeIDMap })
+
+      let trip = await trips.findDocument({ runID: 'C000' })
+
+      expect(trip).to.not.be.null
+      expect(trip.tripID).to.equal('02-PKM--12-T5-C000')
+      expect(trip.shapeID).to.equal('2-PKM-vpt-12.20.R')
+      expect(trip.routeGTFSID).to.equal('2-PKM')
+      expect(trip.block).to.equal('3347')
+      expect(trip.isRailReplacementBus).to.be.false
+
+      expect(trip.stopTimings[0].stopName).to.equal('East Pakenham Railway Station')
+      expect(trip.stopTimings[0].platform).to.equal('1')
+
+      expect(trip.stopTimings[22].stopName).to.equal('Richmond Railway Station')
+      expect(trip.stopTimings[22].platform).to.equal('5')
+
+      expect(trip.stopTimings[27].stopName).to.equal('Flinders Street Railway Station')
+      expect(trip.stopTimings[27].platform).to.equal('7')
+
+      let nextTrip = await trips.findDocument({ block: '3347', runID: { $ne: 'C000' } })
+      expect(nextTrip.runID).to.equal('C005')
+      expect(trip.isRailReplacementBus).to.be.false
+      
+      expect(nextTrip.stopTimings[0].stopName).to.equal('Flinders Street Railway Station')
+      expect(nextTrip.stopTimings[0].platform).to.equal('7')
+    })
+
+    it('It identify rail replacement bus trip', async () => {
+      let database = new LokiDatabaseConnection('test-db')
+      let stops = await database.createCollection('stops')
+      let routes = await database.createCollection('routes')
+      let trips = await database.createCollection('gtfs timetables')
+
+      let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+      await stopLoader.loadStops()
+
+      let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+      await routeLoader.loadRoutes()
+
+      let routeIDMap = routeLoader.getRouteIDMap()
+
+      let tripLoader = new TripLoader({
+        tripsFile, stopTimesFile,
+        calendarFile, calendarDatesFile
+      }, TRANSIT_MODES.metroTrain, database)
+
+      await tripLoader.loadTrips({ routeIDMap })
+
+      let trip = await trips.findDocument({ runID: 'BL000' })
+
+      expect(trip).to.not.be.null
+      expect(trip.tripID).to.equal('02-LIL--13-T5_w3-BL000')
+      expect(trip.shapeID).to.equal('2-LIL-vpt-13.133.R')
+      expect(trip.routeGTFSID).to.equal('2-LIL')
+      expect(trip.block).to.equal(null)
+      expect(trip.isRailReplacementBus).to.be.true
+
+      expect(trip.stopTimings[0].stopName).to.equal('Burnley Railway Station')
+      expect(trip.stopTimings[0].platform).to.equal('RRB')
+
+      expect(trip.stopTimings[3].stopName).to.equal('Parliament Railway Station')
+      expect(trip.stopTimings[3].platform).to.equal('RRB')
+    })
+  })
+})