writer for locations.geojson output (#534)

Co-authored-by: Ian Rees <ian@ianrees.net>

Author: drewda

diff/diff_cmd.go

@@ -17,6 +17,7 @@ import (
 	"github.com/interline-io/transitland-lib/tlcli"
 	"github.com/interline-io/transitland-lib/tlcsv"
 	"github.com/spf13/pflag"
+	"github.com/twpayne/go-geom/encoding/geojson"
 )
 
 type Command struct {
@@ -33,7 +34,9 @@ type Command struct {
 
 func (cmd *Command) HelpDesc() (string, string) {
 	a := "Calculate difference between two feeds, writing output in a GTFS-like format"
-	b := "This command is experimental; it may provide incorrect results or crash on large feeds."
+	b := `This command is experimental; it may provide incorrect results or crash on large feeds.
+
+Note: This command only processes CSV files; GeoJSON files (such as locations.geojson) are not included in the diff comparison.`
 	return a, b
 }
 
@@ -334,6 +337,11 @@ func (adapter *diffAdapter) WriteRows(efn string, rows [][]string) error {
 	return nil
 }
 
+func (adapter *diffAdapter) WriteFeatures(filename string, features []*geojson.Feature) error {
+	// diffAdapter only handles CSV files, so GeoJSON is ignored
+	return nil
+}
+
 type diffKey struct {
 	efn string
 	eid string

doc/cli/transitland_diff.md

@@ -8,6 +8,8 @@ Calculate difference between two feeds, writing output in a GTFS-like format
 
 This command is experimental; it may provide incorrect results or crash on large feeds.
 
+Note: This command only processes CSV files; GeoJSON files (such as locations.geojson) are not included in the diff comparison.
+
 ```
 transitland diff [flags] <feed1> <feed2> <output>
 ```

tlcsv/adapter.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"crypto/sha1"
 	"encoding/csv"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -17,6 +18,7 @@ import (
 	"github.com/interline-io/log"
 	"github.com/interline-io/transitland-lib/causes"
 	"github.com/interline-io/transitland-lib/request"
+	"github.com/twpayne/go-geom/encoding/geojson"
 )
 
 // Adapter provides an interface for working with various kinds of GTFS sources: zip, directory, url.
@@ -35,6 +37,7 @@ type Adapter interface {
 // WriterAdapter provides a writing interface.
 type WriterAdapter interface {
 	WriteRows(string, [][]string) error
+	WriteFeatures(string, []*geojson.Feature) error
 	Adapter
 }
 
@@ -381,15 +384,17 @@ func (adapter *ZipAdapter) findInternalPrefix() (string, error) {
 
 // DirAdapter supports plain directories of CSV files.
 type DirAdapter struct {
-	path  string
-	files map[string]*os.File
+	path            string
+	files           map[string]*os.File
+	geojsonFeatures map[string][]*geojson.Feature
 }
 
 // NewDirAdapter returns an initialized DirAdapter.
 func NewDirAdapter(path string) *DirAdapter {
 	return &DirAdapter{
-		path:  strings.TrimPrefix(path, "file://"),
-		files: map[string]*os.File{},
+		path:            strings.TrimPrefix(path, "file://"),
+		files:           map[string]*os.File{},
+		geojsonFeatures: map[string][]*geojson.Feature{},
 	}
 }
 
@@ -457,8 +462,19 @@ func (adapter *DirAdapter) Open() error {
 	return nil
 }
 
-// Close the adapter.
+// Close the adapter. Flushes any buffered GeoJSON files before closing.
 func (adapter *DirAdapter) Close() error {
+	// Flush all buffered GeoJSON files
+	for filename, features := range adapter.geojsonFeatures {
+		if len(features) > 0 {
+			if err := adapter.flushGeoJSON(filename, features); err != nil {
+				return err
+			}
+		}
+	}
+	adapter.geojsonFeatures = map[string][]*geojson.Feature{}
+
+	// Close all file handles
 	for _, f := range adapter.files {
 		if err := f.Close(); err != nil {
 			return err
@@ -542,6 +558,40 @@ func (adapter *DirAdapter) WriteRows(filename string, rows [][]string) error {
 	return nil
 }
 
+// WriteFeatures buffers GeoJSON features to be written when the adapter is closed.
+// This mirrors how CSV rows are buffered and written.
+func (adapter *DirAdapter) WriteFeatures(filename string, features []*geojson.Feature) error {
+	if len(features) == 0 {
+		return nil
+	}
+	adapter.geojsonFeatures[filename] = append(adapter.geojsonFeatures[filename], features...)
+	return nil
+}
+
+// flushGeoJSON writes all buffered features for a file as a FeatureCollection.
+func (adapter *DirAdapter) flushGeoJSON(filename string, features []*geojson.Feature) error {
+	// Close existing file if open (we need to overwrite, not append)
+	if in, ok := adapter.files[filename]; ok {
+		in.Close()
+		delete(adapter.files, filename)
+	}
+
+	// Create new file
+	in, err := os.Create(filepath.Join(adapter.path, filename))
+	if err != nil {
+		return err
+	}
+	adapter.files[filename] = in
+
+	// Write FeatureCollection
+	fc := geojson.FeatureCollection{
+		Features: features,
+	}
+	encoder := json.NewEncoder(in)
+	encoder.SetIndent("", "  ")
+	return encoder.Encode(&fc)
+}
+
 /////////////////////
 
 // ZipWriterAdapter functions the same as DirAdapter, but writes to a temporary directory, and creates a zip archive when closed.
@@ -564,6 +614,16 @@ func NewZipWriterAdapter(path string) *ZipWriterAdapter {
 
 // Close creates a zip archive of all the written files at the specified destination.
 func (adapter *ZipWriterAdapter) Close() error {
+	// Flush any buffered GeoJSON files first
+	for filename, features := range adapter.DirAdapter.geojsonFeatures {
+		if len(features) > 0 {
+			if err := adapter.DirAdapter.flushGeoJSON(filename, features); err != nil {
+				return err
+			}
+		}
+	}
+	adapter.DirAdapter.geojsonFeatures = map[string][]*geojson.Feature{}
+
 	out, err := os.Create(adapter.outpath)
 	if err != nil {
 		return nil

tlcsv/geojson.go

@@ -15,6 +15,11 @@ import (
 // entity and whether it was successfully parsed.
 type GeoJSONFeatureParser[T any] func(*geojson.Feature) (T, bool)
 
+// GeoJSONFeatureWriter is a callback function for converting a GTFS entity
+// into a GeoJSON feature. It receives the entity and should return the feature
+// and whether it was successfully converted.
+type GeoJSONFeatureWriter[T any] func(T) (*geojson.Feature, bool)
+
 // readGeoJSON reads and parses a GeoJSON FeatureCollection file using a
 // provided parser function. This provides a generic way to read any GeoJSON
 // file format into GTFS entities.
@@ -97,50 +102,54 @@ func (reader *Reader) readLocationsGeoJSON(filename string) ([]gtfs.Location, er
 	return readGeoJSON(reader, filename, parseLocationFeature)
 }
 
-// Example: To add support for level.geojson in the future, create a parser function:
-//
-//   func parseLevelFeature(feature *geojson.Feature) (gtfs.Level, bool) {
-//       level := gtfs.Level{}
-//       if feature.ID != "" {
-//           level.LevelID = tt.NewString(feature.ID)
-//       }
-//       if feature.Properties != nil {
-//           if v, ok := feature.Properties["level_name"].(string); ok {
-//               level.LevelName = tt.NewString(v)
-//           }
-//           if v, ok := feature.Properties["level_index"].(float64); ok {
-//               level.LevelIndex = tt.NewFloat(v)
-//           }
-//       }
-//       // Parse geometry (Polygon or MultiPolygon)
-//       if feature.Geometry != nil {
-//           switch g := feature.Geometry.(type) {
-//           case *geom.Polygon, *geom.MultiPolygon:
-//               g.SetSRID(4326)
-//               level.Geometry = tt.NewGeometry(g)
-//           default:
-//               return level, false
-//           }
-//       }
-//       return level, true
-//   }
-//
-// Then in reader.go, add:
-//
-//   func (reader *Reader) Levels() chan gtfs.Level {
-//       out := make(chan gtfs.Level, bufferSize)
-//       go func() {
-//           defer close(out)
-//           // Try GeoJSON first
-//           levels, err := readGeoJSON(reader, "levels.geojson", parseLevelFeature)
-//           if err == nil {
-//               for _, level := range levels {
-//                   out <- level
-//               }
-//               return
-//           }
-//           // Fall back to CSV
-//           ReadEntities[gtfs.Level](reader, "levels.txt")
-//       }()
-//       return out
-//   }
+// writeLocationFeature converts a gtfs.Location entity to a GeoJSON feature.
+// This is used for locations.geojson (GTFS-Flex extension).
+func writeLocationFeature(loc *gtfs.Location) (*geojson.Feature, bool) {
+	if loc == nil {
+		return nil, false
+	}
+	feature := &geojson.Feature{}
+
+	// Set feature ID from LocationID
+	if loc.LocationID.Val != "" {
+		feature.ID = loc.LocationID.Val
+	}
+
+	// Set properties
+	properties := make(map[string]any)
+	if loc.StopName.Val != "" {
+		properties["stop_name"] = loc.StopName.Val
+	}
+	if loc.StopDesc.Val != "" {
+		properties["stop_desc"] = loc.StopDesc.Val
+	}
+	if loc.ZoneID.Val != "" {
+		properties["zone_id"] = loc.ZoneID.Val
+	}
+	if loc.StopURL.Val != "" {
+		properties["stop_url"] = loc.StopURL.Val
+	}
+	if len(properties) > 0 {
+		feature.Properties = properties
+	}
+
+	// Set geometry - must be Polygon or MultiPolygon for locations
+	if !loc.Geometry.Valid {
+		return nil, false
+	}
+
+	// Ensure SRID is set
+	switch g := loc.Geometry.Val.(type) {
+	case *geom.Polygon:
+		g.SetSRID(4326)
+		feature.Geometry = g
+	case *geom.MultiPolygon:
+		g.SetSRID(4326)
+		feature.Geometry = g
+	default:
+		// Invalid geometry type for location - skip
+		return nil, false
+	}
+
+	return feature, true
+}