use snapToOption string to calculate shapes

Author: josh-willis-arcadis

lib/editor/actions/map/index.js

@@ -165,17 +165,17 @@ export function handleControlPointDrag (
   patternCoordinates: any
 ) {
   return function (dispatch: dispatchFn, getState: getStateFn) {
-    const {avoidMotorways, currentDragId, followStreets} = getState().editor.editSettings.present
+    const {avoidMotorways, currentDragId, snapToOption} = getState().editor.editSettings.present
     recalculateShape({
       avoidMotorways,
       controlPoints,
       defaultToStraightLine: false,
       dragId: currentDragId,
       editType: 'update',
-      followStreets,
       index,
       newPoint: latlng,
-      patternCoordinates
+      patternCoordinates,
+      snapToOption
     }).then(result => {
       const {currentDragId} = getState().editor.editSettings.present
       // If there is a dragId in the store and it matches the result, the user
@@ -207,17 +207,17 @@ export function handleControlPointDragEnd (
     dispatch(controlPointDragOrEnd())
 
     // recalculate shape for final position
-    const {avoidMotorways, followStreets} = getState().editor.editSettings.present
+    const {avoidMotorways, snapToOption} = getState().editor.editSettings.present
     recalculateShape({
       avoidMotorways,
       controlPoints,
       defaultToStraightLine: false,
       editType: 'update',
       index,
-      followStreets,
       newPoint: latlng,
       patternCoordinates,
-      snapControlPointToNewSegment: true
+      snapControlPointToNewSegment: true,
+      snapToOption
     }).then(result => {
       // const {updatedShapePoints: shapePoints, updatedControlPoints} = result
       if (!result.coordinates) {

lib/editor/actions/map/stopStrategies.js

@@ -227,9 +227,10 @@ export function addStopAtInterval (latlng: LatLng, activePattern: Pattern, contr
 }
 
 export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?number) {
+  // eslint-disable-next-line complexity
   return async function (dispatch: dispatchFn, getState: getStateFn) {
     const {data, editSettings} = getState().editor
-    const {avoidMotorways, followStreets} = editSettings.present
+    const {avoidMotorways, snapToOption} = editSettings.present
     const {patternStops: currentPatternStops, shapePoints} = pattern
     const patternStops = clone(currentPatternStops)
     const {controlPoints, patternSegments} = getControlPoints(getState())
@@ -265,7 +266,7 @@ export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?num
       } else {
         dispatch(updatePatternStops(pattern, patternStops))
         // Otherwise, check if a shape ought to be created. Then, save.
-        if (patternStops.length === 2 && followStreets) {
+        if (patternStops.length === 2 && snapToOption) {
           // Create shape between stops the added stop is the second one and
           // followStreets is enabled. Otherwise, there is no need to create a
           // new shape because it would just be a straight line segment anyways.
@@ -277,7 +278,7 @@ export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?num
           }
           const points = [previousStop, stop]
             .map((stop, index) => ({lng: stop.stop_lon, lat: stop.stop_lat}))
-          const patternSegments = await getPolyline(points, true, avoidMotorways)
+          const patternSegments = await getPolyline(points, true, avoidMotorways, snapToOption)
           // Update pattern stops and geometry.
           const controlPoints = controlPointsFromSegments(patternStops, patternSegments)
           dispatch(updatePatternGeometry({controlPoints, patternSegments}))
@@ -330,7 +331,7 @@ export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?num
         // as recalculate shape.
         let result
         try {
-          const newFromSegment = await getSegment(newFromSegmentCoords, true)
+          const newFromSegment = await getSegment(newFromSegmentCoords, true, avoidMotorways, snapToOption)
           const segmentDistance = lineDistance(newFromSegment, 'meters')
           const addedControlPoint = newControlPoint(
             previousStopControlPoint.distance + segmentDistance,
@@ -358,11 +359,11 @@ export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?num
             controlPoints: clonedControlPoints,
             defaultToStraightLine: false,
             editType: 'update',
-            followStreets,
             index: spliceIndex,
             newPoint: {lng: stop.stop_lon, lat: stop.stop_lat},
             snapControlPointToNewSegment: true,
-            patternCoordinates: clonedPatternSegments
+            patternCoordinates: clonedPatternSegments,
+            snapToOption
           })
         } catch (err) {
           console.log(err)
@@ -399,11 +400,11 @@ export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?num
             controlPoints: clonedControlPoints,
             defaultToStraightLine: false,
             editType: 'update',
-            followStreets,
             index,
             newPoint: {lng: stop.stop_lon, lat: stop.stop_lat},
             snapControlPointToNewSegment: true,
-            patternCoordinates: clonedPatternSegments
+            patternCoordinates: clonedPatternSegments,
+            snapToOption
           })
         } catch (err) {
           console.log(err)
@@ -429,12 +430,12 @@ export function addStopToPattern (pattern: Pattern, stop: GtfsStop, index?: ?num
  */
 function extendPatternToPoint (pattern, endPoint, newEndPoint, stop = null, splitInterval = 0) {
   return async function (dispatch: dispatchFn, getState: getStateFn) {
-    const {avoidMotorways, followStreets} = getState().editor.editSettings.present
+    const {avoidMotorways, snapToOption} = getState().editor.editSettings.present
     const {controlPoints, patternSegments} = getControlPoints(getState())
     const clonedControlPoints = clone(controlPoints)
     let newShape
-    if (followStreets) {
-      newShape = await getPolyline([endPoint, newEndPoint], false, avoidMotorways)
+    if (snapToOption) {
+      newShape = await getPolyline([endPoint, newEndPoint], false, avoidMotorways, snapToOption)
     }
     if (!newShape) {
       // Get single coordinate for straight line if polyline fails or if not

lib/editor/components/pattern/EditSettings.js

@@ -59,13 +59,11 @@ export default class EditSettings extends Component<Props, State> {
     const {editSettings, patternSegment, updateEditSetting} = this.props
     const {
       editGeometry,
-      followStreets,
       onMapClick,
-      stopInterval
+      stopInterval,
+      snapToOption
     } = editSettings
     const SETTINGS = [
-      // RAIL-TODO remove snap to streets
-      {type: 'followStreets', label: 'Snap to streets'},
       {type: 'avoidMotorways', label: 'Avoid highways in routing'},
       {type: 'hideStopHandles', label: 'Hide stop handles'},
       {type: 'hideInactiveSegments', label: 'Hide inactive segments'},
@@ -79,19 +77,13 @@ export default class EditSettings extends Component<Props, State> {
         <ControlLabel><small>Snap to options</small></ControlLabel>
         <FormControl
           componentClass='select'
-          value={onMapClick}
-          name={'onMapClick'}
+          value={snapToOption}
+          name={'snapToOption'}
           onChange={this._onSelectChange}>
           {SNAP_TO_OPTIONS.map(v => {
-            // ADD_STOPS_AT_INTERSECTIONS only enabled for nysdot extenstion
-            // (due to custom r5 deployment)
-            // FIXME: Temporarily disable add stops at intersection entirely
-            // (needs to be fixed for sql editor).
-            const disabled = v === 'ADD_STOPS_AT_INTERSECTIONS' // && !isExtensionEnabled('nysdot')
             return (
               <option
                 key={v}
-                disabled={disabled}
                 value={v}>{toSentenceCase(v.replace(/_/g, ' '))}
               </option>
             )
@@ -105,7 +97,7 @@ export default class EditSettings extends Component<Props, State> {
             // this state would cause the entire shape to disappear).
             disabled={
               (s.type === 'hideInactiveSegments' && noSegmentIsActive) ||
-              (s.type === 'avoidMotorways' && !followStreets)
+              (s.type === 'avoidMotorways' && snapToOption !== 'STREET')
             }
             name={s.type}
             style={{margin: '3px 0'}}

lib/editor/components/pattern/EditShapePanel.js

@@ -51,8 +51,8 @@ export default class EditShapePanel extends Component<Props> {
   async drawPatternFromStops (pattern: Pattern, stopsCoordinates: Array<LatLng>, followStreets: boolean): Promise<any> {
     const {editSettings, saveActiveGtfsEntity, setErrorMessage, updatePatternGeometry} = this.props
     let patternSegments = []
-    if (followStreets) {
-      patternSegments = await getPolyline(stopsCoordinates, true, editSettings.present.avoidMotorways)
+    if (editSettings.present.snapToOption !== 'NONE') {
+      patternSegments = await getPolyline(stopsCoordinates, true, editSettings.present.avoidMotorways, editSettings.present.snapToOption)
     } else {
       // Construct straight-line segments using stop coordinates
       stopsCoordinates

lib/editor/reducers/settings.js

@@ -20,7 +20,6 @@ export const defaultState = {
   currentDragId: null,
   distanceFromIntersection: 5,
   editGeometry: false,
-  followStreets: true,
   hideInactiveSegments: false,
   intersectionStep: 2,
   onMapClick: CLICK_OPTIONS[0],
@@ -29,6 +28,7 @@ export const defaultState = {
   showStops: true,
   showTooltips: true,
   hideStopHandles: true,
+  snapToOption: 'NONE',
   stopInterval: 400
 }
 
@@ -96,6 +96,11 @@ export const reducers = {
     action: ActionType<typeof updateEditSetting>
   ): EditSettingsState {
     const {setting, value} = action.payload
-    return update(state, { [setting]: {$set: value} })
+    // RAIL-TODO: make sure followStreet is properly set.
+    // RAIL-TODO: use in a lot of places, make sure nothing breaks????
+    return update(state, {
+      [setting]: {$set: value},
+      followStreets: {$set: value === 'STREET'}
+    })
   }
 }

lib/editor/util/map.js

@@ -262,30 +262,29 @@ export function getPatternEndPoint (pattern: Pattern, controlPoints?: Array<Cont
   throw new Error('Control point is missing coordinates')
 }
 
-// RAIL-TODO: remove followRoad for generic routing options
 /* eslint-disable complexity */
 export async function recalculateShape ({
   avoidMotorways = false,
   controlPoints,
   defaultToStraightLine = true,
   dragId,
   editType,
-  followStreets,
   index,
   newPoint,
   patternCoordinates,
-  snapControlPointToNewSegment = false
+  snapControlPointToNewSegment = false,
+  snapToOption
 }: {
   avoidMotorways?: boolean,
   controlPoints: Array<ControlPoint>,
   defaultToStraightLine?: boolean,
   dragId?: null | string,
   editType: string,
-  followStreets: boolean,
   index: number,
   newPoint?: LatLng,
   patternCoordinates: Array<Coordinates>,
-  snapControlPointToNewSegment?: boolean
+  snapControlPointToNewSegment?: boolean,
+  snapToOption: string
 }): Promise<{
   coordinates: ?Array<any>,
   dragId?: ?string,
@@ -397,12 +396,11 @@ export async function recalculateShape ({
     throw new Error('Invalid editType. Must be either "update" or "delete".')
   }
   // calculate new segment (valhalla or straight line)
-  // RAIL-TODO: remove followRoad for generic routing options
   const newSegment = await getSegment(
     pointsToRoute,
-    followStreets,
     defaultToStraightLine,
-    avoidMotorways
+    avoidMotorways,
+    snapToOption
   )
   if (!newSegment || !newSegment.coordinates) {
     // If new segment calculation is unsuccessful, return null for coordinates and