comparing 900b774f3638e190db482b7475d9b06112a8d8bb and main on anil.recoil.org/ocaml-gpx

+32 -11

.tangled/workflows/build.yml

···

       5
       5
        
       dependencies:

     

       6
       6
        
         nixpkgs:

     

       7
       7
        
           - shell

     

       8
       8
       +
           - stdenv

     

       9
       9
       +
           - findutils

     

       10
       10
       +
           - binutils

     

       11
       11
       +
           - libunwind

     

       12
       12
       +
           - ncurses

     

       13
       13
       +
           - opam

     

       14
       14
       +
           - git

     

       15
       15
       +
           - gawk

     

       16
       16
       +
           - gnupatch

     

       17
       17
       +
           - gnum4

     

       18
       18
       +
           - gnumake

     

       19
       19
       +
           - gnutar

     

       20
       20
       +
           - gnused

     

       21
       21
       +
           - gnugrep

     

       22
       22
       +
           - diffutils

     

       23
       23
       +
           - gzip

     

       24
       24
       +
           - bzip2

     

       8
       25
        
           - gcc

     

       9
       9
       -
           - dune_3

     

       10
       26
        
           - ocaml

     

       11
       11
       -
           - ocamlpackages.xmlm

     

       12
       12
       -
           - ocamlpackages.alcotest

     

       13
       13
       -
           - ocamlpackages.eio

     

       14
       14
       -
           - ocamlpackages.fmt

     

       15
       15
       -
           - ocamlpackages.eio_main

     

       16
       16
       -
           - ocamlpackages.ppx_expect

     

       17
       17
       -
           - ocamlpackages.cmdliner

     

       18
       18
       -
           - ocamlpackages.ptime

     

       19
       27
        
       

     

       20
       28
        
       steps:

     

       21
       21
       -
         - name: dune

     

       29
       29
       +
         - name: opam

     

       30
       30
       +
           command: |

     

       31
       31
       +
              opam init --disable-sandboxing -any

     

       32
       32
       +
         - name: switch

     

       33
       33
       +
           command: |

     

       34
       34
       +
              opam install . --confirm-level=unsafe-yes --deps-only

     

       35
       35
       +
         - name: build

     

       36
       36
       +
           command: |

     

       37
       37
       +
              opam exec -- dune build --verbose

     

       38
       38
       +
         - name: test

     

       22
       39
        
           command: |

     

       23
       23
       -
              dune build

     

       40
       40
       +
              opam exec -- dune runtest --verbose

     

       41
       41
       +
         - name: doc

     

       42
       42
       +
           command: |

     

       43
       43
       +
              opam install -y odoc

     

       44
       44
       +
              opam exec -- dune build @doc

+1 -1

CHANGES.md

···

       1
       1
       -
       # dev

     

       1
       1
       +
       # v1.0.0

     

       2
       2
        
       

     

       3
       3
        
       - Initial public release

+2 -4

README.md

···

       14
       14
        
       dune build @install

     

       15
       15
        
       dune install

     

       16
       16
        
       

     

       17
       17
       -
       # Or use opam (when published)

     

       17
       17
       +
       # Or use opam

     

       18
       18
        
       opam install mlgpx

     

       19
       19
        
       ```

     

       20
       20
        
       

     
···

       63
       63
        
       The library is split into four main components:

     

       64
       64
        
       

     

       65
       65
        
       ### Core Library (`gpx`)

     

       66
       66
       -
       - **Portable**: No Unix dependencies, works with js_of_ocaml

     

       66
       66
       +
       - **Portable**: No Unix dependencies, works with `js_of_ocaml`

     

       67
       67
        
       - **Streaming**: Uses xmlm for memory-efficient XML processing

     

       68
       68
        
       - **Type-safe**: Strong typing with validation for coordinates and GPS data

     

       69
       69
        
       - **Pure functional**: No side effects in the core parsing/writing logic

     
···

       283
       283
        
       

     

       284
       284
        
       let () = create_simple_gpx ()

     

       285
       285
        
       ```

     

       286
       286
       -
       

     

       287
       287
       -

+1 -1

bin/dune

···

       1
       1
        
       (executable

     

       2
       2
        
        (public_name mlgpx)

     

       3
       3
        
        (name mlgpx_cli)

     

       4
       4
       -
        (libraries gpx gpx_eio cmdliner eio_main fmt fmt.tty fmt.cli))
     

       4
       4
       +
        (libraries gpx gpx_eio cmdliner eio_main fmt fmt.tty fmt.cli))

+5 -1

dune-project

···

       1
       1
        
       (lang dune 3.18)

     

       2
       2
        
       

     

       3
       3
       +
       (name mlgpx)

     

       4
       4
       +
       

     

       3
       5
        
       (generate_opam_files true)

     

       4
       6
        
       

     

       5
       7
        
       (package

     

       6
       8
        
        (name mlgpx)

     

       7
       7
       -
        (depends ocaml dune xmlm ptime eio ppx_expect alcotest eio_main cmdliner fmt logs)

     

       9
       9
       +
        (depends ocaml dune xmlm ptime (eio (>= 1.2)) ppx_expect alcotest eio_main cmdliner fmt logs)

     

       8
       10
        
        (synopsis "Library and CLI for parsing and generating GPS Exchange (GPX) formats")

     

       9
       11
        
        (description

     

       10
       12
        
         "mlgpx is a streaming GPX (GPS Exchange Format) library for OCaml. It provides a portable core library using the xmlm streaming XML parser, with a separate Unix layer for file I/O operations. The library supports the complete GPX 1.1 specification including waypoints, routes, tracks, and metadata with strong type safety and validation.")

     

       11
       13
        
        (license ISC)

     

       12
       14
        
        (authors "Anil Madhavapeddy")

     

       13
       15
        
        (homepage "https://tangled.sh/@anil.recoil.org/ocaml-gpx")

     

       16
       16
       +
        (maintainers "Anil Madhavapeddy <anil@recoil.org>")

     

       17
       17
       +
        (bug_reports https://tangled.sh/@anil.recoil.org/ocaml-gpx/issues)

     

       14
       18
        
        (maintenance_intent "(latest)")

     

       15
       19
        
       )

example_output.gpx

This is a binary file and will not be displayed.

+8 -12

lib/gpx/doc.ml

···

       149
       149
        
         has_time = has_time t;

     

       150
       150
        
       }

     

       151
       151
        
       

     

       152
       152
       +
       (** Pretty print statistics *)

     

       153
       153
       +
       let pp_stats ppf t =

     

       154
       154
       +
         let s = stats t in

     

       155
       155
       +
         Format.fprintf ppf "@[<v>GPX Statistics:@,  Waypoints: %d@,  Routes: %d@,  Tracks: %d@,  Total points: %d@,  Has elevation data: %s@,  Has time data: %s@]"

     

       156
       156
       +
           s.waypoint_count s.route_count s.track_count s.total_points

     

       157
       157
       +
           (if s.has_elevation then "yes" else "no")

     

       158
       158
       +
           (if s.has_time then "yes" else "no")

     

       159
       159
       +
       

     

       152
       160
        
       (** {2 Comparison and Utilities} *)

     

       153
       161
        
       

     

       154
       162
        
       (** Compare documents *)

     
···

       176
       184
        
           t.version t.creator 

     

       177
       185
        
           stats.waypoint_count stats.route_count stats.track_count stats.total_points

     

       178
       186
        
       

     

       179
       179
       -
       (** Print document statistics *)

     

       180
       180
       -
       let print_stats t =

     

       181
       181
       -
         let stats = stats t in

     

       182
       182
       -
         Printf.printf "GPX Statistics:\n";

     

       183
       183
       -
         Printf.printf "  Version: %s\n" t.version;

     

       184
       184
       -
         Printf.printf "  Creator: %s\n" t.creator;

     

       185
       185
       -
         Printf.printf "  Waypoints: %d\n" stats.waypoint_count;

     

       186
       186
       -
         Printf.printf "  Routes: %d\n" stats.route_count;

     

       187
       187
       -
         Printf.printf "  Tracks: %d\n" stats.track_count;

     

       188
       188
       -
         Printf.printf "  Total points: %d\n" stats.total_points;

     

       189
       189
       -
         Printf.printf "  Has elevation data: %s\n" (if stats.has_elevation then "yes" else "no");

     

       190
       190
       -
         Printf.printf "  Has time data: %s\n" (if stats.has_time then "yes" else "no")

+4 -4

lib/gpx/doc.mli

···

       113
       113
        
       (** Get document statistics *)

     

       114
       114
        
       val stats : t -> stats

     

       115
       115
        
       

     

       116
       116
       +
       (** Pretty print statistics *)

     

       117
       117
       +
       val pp_stats : Format.formatter -> t -> unit

     

       118
       118
       +
       

     

       116
       119
        
       (** {2 Comparison and Utilities} *)

     

       117
       120
        
       

     

       118
       121
        
       (** Compare documents *)

     
···

       122
       125
        
       val equal : t -> t -> bool

     

       123
       126
        
       

     

       124
       127
        
       (** Pretty print document *)

     

       125
       125
       -
       val pp : Format.formatter -> t -> unit

     

       126
       126
       -
       

     

       127
       127
       -
       (** Print document statistics to stdout *)

     

       128
       128
       -
       val print_stats : t -> unit
     

       128
       128
       +
       val pp : Format.formatter -> t -> unit

+14 -1

lib/gpx/dune

···

       2
       2
        
        (public_name mlgpx.core)

     

       3
       3
        
        (name gpx)

     

       4
       4
        
        (libraries xmlm ptime)

     

       5
       5
       -
        (modules gpx parser writer validate coordinate link extension waypoint metadata route track error doc))
     

       5
       5
       +
        (modules

     

       6
       6
       +
         gpx

     

       7
       7
       +
         parser

     

       8
       8
       +
         writer

     

       9
       9
       +
         validate

     

       10
       10
       +
         coordinate

     

       11
       11
       +
         link

     

       12
       12
       +
         extension

     

       13
       13
       +
         waypoint

     

       14
       14
       +
         metadata

     

       15
       15
       +
         route

     

       16
       16
       +
         track

     

       17
       17
       +
         error

     

       18
       18
       +
         doc))

+2 -2

lib/gpx/gpx.mli

···

       499
       499
        
           This core module provides the foundation. For complete applications, consider:

     

       500
       500
        
           

     

       501
       501
        
           - {!Gpx_unix}: File I/O operations using standard Unix libraries

     

       502
       502
       -
           - [Gpx_eio]: Concurrent file I/O using the Eio effects library  

     

       502
       502
       +
           - {!Gpx_eio}: Concurrent file I/O using the Eio effects library  

     

       503
       503
        
           - {{:https://erratique.ch/software/xmlm}Xmlm}: Underlying XML processing library

     

       504
       504
        
           - {{:https://erratique.ch/software/ptime}Ptime}: Time representation used for timestamps

     

       505
       505
        
           

     
···

       508
       508
        
           - {{:https://www.topografix.com/gpx.asp}Official GPX specification}

     

       509
       509
        
           - {{:https://www.topografix.com/GPX/1/1/gpx.xsd}GPX 1.1 XML Schema}

     

       510
       510
        
           - {{:https://en.wikipedia.org/wiki/GPS_Exchange_Format}GPX Format on Wikipedia}

     

       511
       511
       -
           - {{:https://en.wikipedia.org/wiki/World_Geodetic_System}WGS84 Coordinate System} *)
     

       511
       511
       +
           - {{:https://en.wikipedia.org/wiki/World_Geodetic_System}WGS84 Coordinate System} *)

+1 -1

lib/gpx_eio/dune

···

       2
       2
        
        (public_name mlgpx.eio)

     

       3
       3
        
        (name gpx_eio)

     

       4
       4
        
        (libraries eio xmlm ptime gpx)

     

       5
       5
       -
        (modules gpx_io gpx_eio))
     

       5
       5
       +
        (modules gpx_io gpx_eio))

+6 -70

lib/gpx_eio/gpx_eio.ml

···

       1
       1
       -
       (** High-level Eio API for GPX operations *)

     

       1
       1
       +
       (** Eio API for GPX operations *)

     

       2
       2
        
       

     

       3
       3
       -
       (* I/O module *)

     

       4
       3
        
       module IO = Gpx_io

     

       5
       5
       -
       

     

       6
       6
       -
       (** Convenience functions for common operations *)

     

       7
       4
        
       

     

       8
       5
        
       (** Read and parse GPX file *)

     

       9
       6
        
       let read ?(validate=false) ~fs path = IO.read_file ~validate ~fs path

     
···

       20
       17
        
       (** Write GPX to Eio sink *)

     

       21
       18
        
       let to_sink ?(validate=false) sink gpx = IO.write_sink ~validate sink gpx

     

       22
       19
        
       

     

       23
       23
       -
       (** Create simple waypoint *)

     

       24
       24
       -
       let make_waypoint ~fs:_ ~lat ~lon ?name ?desc () =

     

       25
       25
       -
         match (Gpx.Coordinate.latitude lat, Gpx.Coordinate.longitude lon) with

     

       26
       26
       -
         | (Ok lat, Ok lon) ->

     

       27
       27
       -
           let wpt = Gpx.Waypoint.make lat lon in

     

       28
       28
       -
           { wpt with name; desc }

     

       29
       29
       -
         | (Error e, _) | (_, Error e) -> failwith ("Invalid coordinate: " ^ e)

     

       30
       30
       -
       

     

       31
       31
       -
       (** Create simple track from coordinate list *)

     

       32
       32
       -
       let make_track_from_coords ~fs:_ ~name coords = 

     

       33
       33
       -
         Gpx.Track.make_from_coords ~name coords

     

       34
       34
       -
       

     

       35
       35
       -
       (** Create simple route from coordinate list *)

     

       36
       36
       -
       let make_route_from_coords ~fs:_ ~name coords = 

     

       37
       37
       -
         Gpx.Route.make_from_coords ~name coords

     

       38
       38
       -
       

     

       39
       39
       -
       (** Extract coordinates from waypoints *)

     

       40
       40
       -
       let waypoint_coords wpt = Gpx.Waypoint.to_floats wpt

     

       41
       41
       -
       

     

       42
       42
       -
       (** Extract coordinates from track *)

     

       43
       43
       -
       let track_coords trk = Gpx.Track.to_coords trk

     

       44
       44
       -
       

     

       45
       45
       -
       (** Extract coordinates from route *)

     

       46
       46
       -
       let route_coords rte = Gpx.Route.to_coords rte

     

       47
       47
       -
       

     

       48
       48
       -
       (** Count total points in GPX *)

     

       49
       49
       -
       let count_points gpx = 

     

       50
       50
       -
         let waypoints = Gpx.Doc.waypoints gpx in

     

       51
       51
       -
         let routes = Gpx.Doc.routes gpx in  

     

       52
       52
       -
         let tracks = Gpx.Doc.tracks gpx in

     

       53
       53
       -
         List.length waypoints + 

     

       54
       54
       -
         List.fold_left (fun acc r -> acc + List.length (Gpx.Route.points r)) 0 routes +

     

       55
       55
       -
         List.fold_left (fun acc t -> acc + Gpx.Track.point_count t) 0 tracks

     

       56
       56
       -
       

     

       57
       57
       -
       (** Get GPX statistics *)

     

       58
       58
       -
       type gpx_stats = {

     

       59
       59
       -
         waypoint_count : int;

     

       60
       60
       -
         route_count : int;

     

       61
       61
       -
         track_count : int;

     

       62
       62
       -
         total_points : int;

     

       63
       63
       -
         has_elevation : bool;

     

       64
       64
       -
         has_time : bool;

     

       65
       65
       -
       }

     

       66
       66
       -
       

     

       67
       67
       -
       let stats gpx =

     

       68
       68
       -
         let waypoints = Gpx.Doc.waypoints gpx in

     

       69
       69
       -
         let routes = Gpx.Doc.routes gpx in  

     

       70
       70
       -
         let tracks = Gpx.Doc.tracks gpx in

     

       71
       71
       -
         {

     

       72
       72
       -
           waypoint_count = List.length waypoints;

     

       73
       73
       -
           route_count = List.length routes;

     

       74
       74
       -
           track_count = List.length tracks;  

     

       75
       75
       -
           total_points = count_points gpx;

     

       76
       76
       -
           has_elevation = List.exists (fun w -> Gpx.Waypoint.elevation w <> None) waypoints;

     

       77
       77
       -
           has_time = List.exists (fun w -> Gpx.Waypoint.time w <> None) waypoints;

     

       78
       78
       -
         }

     

       79
       79
       -
       

     

       80
       20
        
       (** Pretty print GPX statistics *)

     

       81
       81
       -
       let print_stats gpx =

     

       82
       82
       -
         let stats = stats gpx in

     

       83
       83
       -
         Printf.printf "GPX Statistics:\\n";

     

       84
       84
       -
         Printf.printf "  Waypoints: %d\\n" stats.waypoint_count;

     

       85
       85
       -
         Printf.printf "  Routes: %d\\n" stats.route_count;

     

       86
       86
       -
         Printf.printf "  Tracks: %d\\n" stats.track_count;

     

       87
       87
       -
         Printf.printf "  Total Points: %d\\n" stats.total_points;

     

       88
       88
       -
         Printf.printf "  Has Elevation: %b\\n" stats.has_elevation;

     

       89
       89
       -
         Printf.printf "  Has Time: %b\\n" stats.has_time
     

       21
       21
       +
       let print_stats sink gpx =

     

       22
       22
       +
         let buf = Buffer.create 256 in

     

       23
       23
       +
         let fmt = Format.formatter_of_buffer buf in

     

       24
       24
       +
         Format.fprintf fmt "%a@?" Gpx.Doc.pp_stats gpx;

     

       25
       25
       +
         Eio.Flow.copy_string (Buffer.contents buf) sink

+11 -74

lib/gpx_eio/gpx_eio.mli

···

       1
       1
       -
       (** {1 GPX Eio - High-level Eio API for GPX operations}

     

       1
       1
       +
       (** {1 Eio API for GPX operations}

     

       2
       2
        
       

     

       3
       3
       -
           This module provides a high-level API for GPX operations using Eio's 

     

       3
       3
       +
           This module provides a direct-style API for GPX operations using Eio's 

     

       4
       4
        
           effects-based concurrent I/O system. It offers convenient functions

     

       5
       5
        
           for common GPX operations while maintaining structured concurrency.

     

       6
       6
        
       

     
···

       13
       13
        
               let fs = Eio.Stdenv.fs env in

     

       14
       14
        
               

     

       15
       15
        
               (* Create a GPX document *)

     

       16
       16
       -
               let lat = Gpx.latitude 37.7749 |> Result.get_ok in

     

       17
       17
       -
               let lon = Gpx.longitude (-122.4194) |> Result.get_ok in

     

       18
       18
       -
               let wpt = make_waypoint fs ~lat:(Gpx.latitude_to_float lat) ~lon:(Gpx.longitude_to_float lon) ~name:"San Francisco" () in

     

       19
       19
       -
               let gpx = Gpx.make_gpx ~creator:"eio-example" in

     

       20
       20
       -
               let gpx = { gpx with waypoints = [wpt] } in

     

       16
       16
       +
               let lat = Gpx.Coordinate.latitude 37.7749 |> Result.get_ok in

     

       17
       17
       +
               let lon = Gpx.Coordinate.longitude (-122.4194) |> Result.get_ok in

     

       18
       18
       +
               let wpt = Gpx.Waypoint.make lat lon |> Gpx.Waypoint.with_name "San Francisco" in

     

       19
       19
       +
               let gpx = Gpx.make_gpx ~creator:"eio-example" |> Gpx.Doc.add_waypoint wpt in

     

       21
       20
        
               

     

       22
       21
        
               (* Write with validation *)

     

       23
       22
        
               write ~validate:true fs "output.gpx" gpx;

     

       24
       23
        
               

     

       25
       24
        
               (* Read it back *)

     

       26
       25
        
               let gpx2 = read ~validate:true fs "output.gpx" in

     

       27
       27
       -
               Printf.printf "Read %d waypoints\n" (List.length gpx2.waypoints)

     

       26
       26
       +
               Printf.printf "Read %d waypoints\n" (List.length (Gpx.Doc.waypoints gpx2))

     

       28
       27
        
       

     

       29
       28
        
             let () = Eio_main.run main

     

       30
       29
        
           ]}

     
···

       36
       35
        
       

     

       37
       36
        
       (** {2 Convenience File Operations}

     

       38
       37
        
       

     

       39
       39
       -
           These functions provide simple file I/O with the filesystem from [Eio.Stdenv.fs]. *)

     

       38
       38
       +
           These functions provide simple file I/O with the filesystem from {!Eio.Stdenv.fs}. *)

     

       40
       39
        
       

     

       41
       40
        
       (** Read and parse GPX file.

     

       42
       41
        
           @param fs Filesystem capability

     
···

       81
       80
        
           @raises Gpx.Gpx_error on write failure *)

     

       82
       81
        
       val to_sink : ?validate:bool -> [> Eio.Flow.sink_ty ] Eio.Resource.t -> Gpx.t -> unit

     

       83
       82
        
       

     

       84
       84
       -
       (** {2 Utility Functions} *)

     

       85
       85
       -
       

     

       86
       86
       -
       (** Create simple waypoint with coordinates.

     

       87
       87
       -
           @param fs Filesystem capability (unused, for API consistency)

     

       88
       88
       -
           @param lat Latitude in degrees

     

       89
       89
       -
           @param lon Longitude in degrees  

     

       90
       90
       -
           @param ?name Optional waypoint name

     

       91
       91
       -
           @param ?desc Optional waypoint description

     

       92
       92
       -
           @return Waypoint data

     

       93
       93
       -
           @raises Gpx.Gpx_error on invalid coordinates *)

     

       94
       94
       -
       val make_waypoint : fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> lat:float -> lon:float -> ?name:string -> ?desc:string -> unit -> Gpx.Waypoint.t

     

       95
       95
       -
       

     

       96
       96
       -
       (** Create track from coordinate list.

     

       97
       97
       -
           @param fs Filesystem capability (unused, for API consistency)

     

       98
       98
       -
           @param name Track name

     

       99
       99
       -
           @param coords List of (latitude, longitude) pairs

     

       100
       100
       -
           @return Track with single segment

     

       101
       101
       -
           @raises Gpx.Gpx_error on invalid coordinates *)

     

       102
       102
       -
       val make_track_from_coords : fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> name:string -> (float * float) list -> Gpx.Track.t

     

       103
       103
       -
       

     

       104
       104
       -
       (** Create route from coordinate list.

     

       105
       105
       -
           @param fs Filesystem capability (unused, for API consistency)

     

       106
       106
       -
           @param name Route name  

     

       107
       107
       -
           @param coords List of (latitude, longitude) pairs

     

       108
       108
       -
           @return Route

     

       109
       109
       -
           @raises Gpx.Gpx_error on invalid coordinates *)

     

       110
       110
       -
       val make_route_from_coords : fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> name:string -> (float * float) list -> Gpx.Route.t

     

       111
       111
       -
       

     

       112
       112
       -
       (** Extract coordinates from waypoint.

     

       113
       113
       -
           @param wpt Waypoint data

     

       114
       114
       -
           @return (latitude, longitude) as floats *)

     

       115
       115
       -
       val waypoint_coords : Gpx.Waypoint.t -> float * float

     

       116
       116
       -
       

     

       117
       117
       -
       (** Extract coordinates from track.

     

       118
       118
       -
           @param track Track

     

       119
       119
       -
           @return List of (latitude, longitude) pairs *)

     

       120
       120
       -
       val track_coords : Gpx.Track.t -> (float * float) list

     

       121
       121
       -
       

     

       122
       122
       -
       (** Extract coordinates from route.

     

       123
       123
       -
           @param route Route

     

       124
       124
       -
           @return List of (latitude, longitude) pairs *)

     

       125
       125
       -
       val route_coords : Gpx.Route.t -> (float * float) list

     

       126
       126
       -
       

     

       127
       127
       -
       (** Count total points in GPX document.

     

       128
       128
       -
           @param gpx GPX document

     

       129
       129
       -
           @return Total number of waypoints, route points, and track points *)

     

       130
       130
       -
       val count_points : Gpx.t -> int

     

       131
       131
       -
       

     

       132
       132
       -
       (** GPX statistics record *)

     

       133
       133
       -
       type gpx_stats = {

     

       134
       134
       -
         waypoint_count : int;      (** Number of waypoints *)

     

       135
       135
       -
         route_count : int;         (** Number of routes *)

     

       136
       136
       -
         track_count : int;         (** Number of tracks *)

     

       137
       137
       -
         total_points : int;        (** Total geographic points *)

     

       138
       138
       -
         has_elevation : bool;      (** Document contains elevation data *)

     

       139
       139
       -
         has_time : bool;          (** Document contains time data *)

     

       140
       140
       -
       }

     

       141
       141
       -
       

     

       142
       142
       -
       (** Get GPX document statistics.

     

       143
       143
       -
           @param gpx GPX document

     

       144
       144
       -
           @return Statistics summary *)

     

       145
       145
       -
       val stats : Gpx.t -> gpx_stats

     

       146
       146
       -
       

     

       147
       147
       -
       (** Print GPX statistics to stdout.

     

       83
       83
       +
       (** Print GPX statistics to sink.

     

       84
       84
       +
           @param sink Output sink

     

       148
       85
        
           @param gpx GPX document *)

     

       149
       149
       -
       val print_stats : Gpx.t -> unit

     

       86
       86
       +
       val print_stats : [> Eio.Flow.sink_ty ] Eio.Resource.t -> Gpx.t -> unit

+1 -3

lib/gpx_eio/gpx_io.ml

···

       1
       1
        
       (** GPX Eio I/O operations *)

     

       2
       2
        
       

     

       3
       3
       -
       (* Real Eio-based I/O operations *)

     

       4
       4
       -
       

     

       5
       3
        
       (** Read GPX from file path *)

     

       6
       4
        
       let read_file ?(validate=false) ~fs path =

     

       7
       5
        
         let content = Eio.Path.load Eio.Path.(fs / path) in

     
···

       71
       69
        
               Eio.Path.save ~create:(`Or_truncate 0o644) Eio.Path.(fs / path) backup_content

     

       72
       70
        
             with _ -> () (* Ignore restore errors *)

     

       73
       71
        
           );

     

       74
       74
       -
           raise err
     

       72
       72
       +
           raise err

+1 -1

lib/gpx_unix/dune

···

       2
       2
        
        (public_name mlgpx.unix)

     

       3
       3
        
        (name gpx_unix)

     

       4
       4
        
        (libraries unix xmlm ptime gpx)

     

       5
       5
       -
        (modules gpx_io gpx_unix))
     

       5
       5
       +
        (modules gpx_io gpx_unix))

+2 -111

lib/gpx_unix/gpx_unix.ml

···

       1
       1
       -
       (** High-level Unix API for GPX operations *)

     

       2
       2
       -
       

     

       3
       3
       -
       (** Result binding operators *)

     

       4
       4
       -
       let (let*) = Result.bind

     

       1
       1
       +
       (** Unix API for GPX operations *)

     

       5
       2
        
       

     

       6
       6
       -
       (* Re-export IO module *)

     

       7
       3
        
       module IO = Gpx_io

     

       8
       8
       -
       

     

       9
       9
       -
       (* Re-export common types *)

     

       10
       4
        
       open Gpx

     

       11
       5
        
       

     

       12
       6
        
       (** Convenience functions for common operations *)

     
···

       20
       14
        
       (** Write GPX to file with backup *)

     

       21
       15
        
       let write_with_backup = IO.write_file_with_backup

     

       22
       16
        
       

     

       23
       23
       -
       (** Convert GPX to string *)

     

       24
       24
       -
       let to_string = write_string

     

       25
       25
       -
       

     

       26
       26
       -
       (** Parse GPX from string *)

     

       27
       27
       -
       let from_string = parse_string

     

       28
       28
       -
       

     

       29
       29
       -
       (** Quick validation check *)

     

       30
       30
       -
       let is_valid = is_valid

     

       31
       31
       -
       

     

       32
       32
       -
       (** Get validation issues *)

     

       33
       33
       -
       let validate = validate_gpx

     

       34
       34
       -
       

     

       35
       35
       -
       (** Create simple waypoint *)

     

       36
       36
       -
       let make_waypoint ~lat ~lon ?name ?desc () =

     

       37
       37
       -
         match (Coordinate.latitude lat, Coordinate.longitude lon) with

     

       38
       38
       -
         | (Ok lat, Ok lon) ->

     

       39
       39
       -
           let wpt = Waypoint.make lat lon in

     

       40
       40
       -
           let wpt = { wpt with name; desc } in

     

       41
       41
       -
           Ok wpt

     

       42
       42
       -
         | (Error e, _) | (_, Error e) -> Error (Gpx.Error.invalid_coordinate e)

     

       43
       43
       -
       

     

       44
       44
       -
       (** Create simple track from coordinate list *)

     

       45
       45
       -
       let make_track_from_coords ~name coords =

     

       46
       46
       -
         let make_trkpt (lat, lon) =

     

       47
       47
       -
           match (Coordinate.latitude lat, Coordinate.longitude lon) with

     

       48
       48
       -
           | (Ok lat, Ok lon) -> Ok (Waypoint.make lat lon)

     

       49
       49
       -
           | (Error e, _) | (_, Error e) -> Error (Gpx.Error.invalid_coordinate e)

     

       50
       50
       -
         in

     

       51
       51
       -
         let rec convert_coords acc = function

     

       52
       52
       -
           | [] -> Ok (List.rev acc)

     

       53
       53
       -
           | coord :: rest ->

     

       54
       54
       -
             match make_trkpt coord with

     

       55
       55
       -
             | Ok trkpt -> convert_coords (trkpt :: acc) rest

     

       56
       56
       -
             | Error e -> Error e

     

       57
       57
       -
         in

     

       58
       58
       -
         let* _trkpts = convert_coords [] coords in

     

       59
       59
       -
         Ok (Track.make_from_coords ~name coords)

     

       60
       60
       -
       

     

       61
       61
       -
       (** Create simple route from coordinate list *)

     

       62
       62
       -
       let make_route_from_coords ~name coords =

     

       63
       63
       -
         let make_rtept (lat, lon) =

     

       64
       64
       -
           match (Coordinate.latitude lat, Coordinate.longitude lon) with

     

       65
       65
       -
           | (Ok lat, Ok lon) -> Ok (Waypoint.make lat lon)

     

       66
       66
       -
           | (Error e, _) | (_, Error e) -> Error (Gpx.Error.invalid_coordinate e)

     

       67
       67
       -
         in

     

       68
       68
       -
         let rec convert_coords acc = function

     

       69
       69
       -
           | [] -> Ok (List.rev acc)

     

       70
       70
       -
           | coord :: rest ->

     

       71
       71
       -
             match make_rtept coord with

     

       72
       72
       -
             | Ok rtept -> convert_coords (rtept :: acc) rest

     

       73
       73
       -
             | Error e -> Error e

     

       74
       74
       -
         in

     

       75
       75
       -
         let* _rtepts = convert_coords [] coords in

     

       76
       76
       -
         Ok (Route.make_from_coords ~name coords)

     

       77
       77
       -
       

     

       78
       78
       -
       (** Extract coordinates from waypoints *)

     

       79
       79
       -
       let waypoint_coords wpt = Waypoint.to_floats wpt

     

       80
       80
       -
       

     

       81
       81
       -
       (** Extract coordinates from track *)

     

       82
       82
       -
       let track_coords track = Track.to_coords track

     

       83
       83
       -
       

     

       84
       84
       -
       (** Extract coordinates from route *)

     

       85
       85
       -
       let route_coords route = Route.to_coords route

     

       86
       86
       -
       

     

       87
       87
       -
       (** Count total points in GPX *)

     

       88
       88
       -
       let count_points gpx =

     

       89
       89
       -
         let waypoints = Doc.waypoints gpx in

     

       90
       90
       -
         let routes = Doc.routes gpx in  

     

       91
       91
       -
         let tracks = Doc.tracks gpx in

     

       92
       92
       -
         List.length waypoints + 

     

       93
       93
       -
         List.fold_left (fun acc r -> acc + List.length (Route.points r)) 0 routes +

     

       94
       94
       -
         List.fold_left (fun acc t -> acc + Track.point_count t) 0 tracks

     

       95
       95
       -
       

     

       96
       96
       -
       (** Get GPX statistics *)

     

       97
       97
       -
       type gpx_stats = {

     

       98
       98
       -
         waypoint_count : int;

     

       99
       99
       -
         route_count : int;

     

       100
       100
       -
         track_count : int;

     

       101
       101
       -
         total_points : int;

     

       102
       102
       -
         has_elevation : bool;

     

       103
       103
       -
         has_time : bool;

     

       104
       104
       -
       }

     

       105
       105
       -
       

     

       106
       106
       -
       let stats gpx =

     

       107
       107
       -
         let waypoints = Doc.waypoints gpx in

     

       108
       108
       -
         let routes = Doc.routes gpx in  

     

       109
       109
       -
         let tracks = Doc.tracks gpx in

     

       110
       110
       -
         {

     

       111
       111
       -
           waypoint_count = List.length waypoints;

     

       112
       112
       -
           route_count = List.length routes;

     

       113
       113
       -
           track_count = List.length tracks;  

     

       114
       114
       -
           total_points = count_points gpx;

     

       115
       115
       -
           has_elevation = List.exists (fun w -> Waypoint.elevation w <> None) waypoints;

     

       116
       116
       -
           has_time = List.exists (fun w -> Waypoint.time w <> None) waypoints;

     

       117
       117
       -
         }

     

       118
       118
       -
       

     

       119
       17
        
       (** Pretty print GPX statistics *)

     

       120
       18
        
       let print_stats gpx =

     

       121
       121
       -
         let stats = stats gpx in

     

       122
       122
       -
         Printf.printf "GPX Statistics:\n";

     

       123
       123
       -
         Printf.printf "  Waypoints: %d\n" stats.waypoint_count;

     

       124
       124
       -
         Printf.printf "  Routes: %d\n" stats.route_count;

     

       125
       125
       -
         Printf.printf "  Tracks: %d\n" stats.track_count;

     

       126
       126
       -
         Printf.printf "  Total points: %d\n" stats.total_points;

     

       127
       127
       -
         Printf.printf "  Has elevation data: %s\n" (if stats.has_elevation then "yes" else "no");

     

       128
       128
       -
         Printf.printf "  Has time data: %s\n" (if stats.has_time then "yes" else "no")
     

       19
       19
       +
         Format.printf "%a@." Doc.pp_stats gpx

+2 -54

lib/gpx_unix/gpx_unix.mli

···

       1
       1
       -
       (** High-level Unix API for GPX operations *)

     

       1
       1
       +
       (** Unix API for GPX operations *)

     

       2
       2
        
       

     

       3
       3
       -
       (* Re-export IO module *)

     

       4
       4
       -
       module IO = Gpx_io

     

       5
       5
       -
       

     

       6
       6
       -
       (* Re-export common types *)

     

       7
       3
        
       open Gpx

     

       8
       4
        
       

     

       9
       9
       -
       (** Convenience functions for common operations *)

     

       10
       10
       -
       

     

       11
       5
        
       (** Read and parse GPX file *)

     

       12
       6
        
       val read : ?validate:bool -> string -> (t, error) result

     

       13
       7
        
       

     
···

       17
       11
        
       (** Write GPX to file with backup *)

     

       18
       12
        
       val write_with_backup : ?validate:bool -> string -> t -> (string, error) result

     

       19
       13
        
       

     

       20
       20
       -
       (** Convert GPX to string *)

     

       21
       21
       -
       val to_string : ?validate:bool -> t -> (string, error) result

     

       22
       22
       -
       

     

       23
       23
       -
       (** Parse GPX from string *)

     

       24
       24
       -
       val from_string : ?validate:bool -> string -> (t, error) result

     

       25
       25
       -
       

     

       26
       26
       -
       (** Quick validation check *)

     

       27
       27
       -
       val is_valid : t -> bool

     

       28
       28
       -
       

     

       29
       29
       -
       (** Get validation issues *)

     

       30
       30
       -
       val validate : t -> validation_result

     

       31
       31
       -
       

     

       32
       32
       -
       (** Create simple waypoint *)

     

       33
       33
       -
       val make_waypoint : lat:float -> lon:float -> ?name:string -> ?desc:string -> unit -> (Waypoint.t, error) result

     

       34
       34
       -
       

     

       35
       35
       -
       (** Create simple track from coordinate list *)

     

       36
       36
       -
       val make_track_from_coords : name:string -> (float * float) list -> (Track.t, error) result

     

       37
       37
       -
       

     

       38
       38
       -
       (** Create simple route from coordinate list *)

     

       39
       39
       -
       val make_route_from_coords : name:string -> (float * float) list -> (Route.t, error) result

     

       40
       40
       -
       

     

       41
       41
       -
       (** Extract coordinates from waypoints *)

     

       42
       42
       -
       val waypoint_coords : Waypoint.t -> float * float

     

       43
       43
       -
       

     

       44
       44
       -
       (** Extract coordinates from track *)

     

       45
       45
       -
       val track_coords : Track.t -> (float * float) list

     

       46
       46
       -
       

     

       47
       47
       -
       (** Extract coordinates from route *)

     

       48
       48
       -
       val route_coords : Route.t -> (float * float) list

     

       49
       49
       -
       

     

       50
       50
       -
       (** Count total points in GPX *)

     

       51
       51
       -
       val count_points : t -> int

     

       52
       52
       -
       

     

       53
       53
       -
       (** GPX statistics *)

     

       54
       54
       -
       type gpx_stats = {

     

       55
       55
       -
         waypoint_count : int;

     

       56
       56
       -
         route_count : int;

     

       57
       57
       -
         track_count : int;

     

       58
       58
       -
         total_points : int;

     

       59
       59
       -
         has_elevation : bool;

     

       60
       60
       -
         has_time : bool;

     

       61
       61
       -
       }

     

       62
       62
       -
       

     

       63
       63
       -
       (** Get GPX statistics *)

     

       64
       64
       -
       val stats : t -> gpx_stats

     

       65
       65
       -
       

     

       66
       14
        
       (** Pretty print GPX statistics *)

     

       67
       67
       -
       val print_stats : t -> unit
     

       15
       15
       +
       val print_stats : t -> unit

+4 -1

mlgpx.opam

···

       4
       4
        
         "Library and CLI for parsing and generating GPS Exchange (GPX) formats"

     

       5
       5
        
       description:

     

       6
       6
        
         "mlgpx is a streaming GPX (GPS Exchange Format) library for OCaml. It provides a portable core library using the xmlm streaming XML parser, with a separate Unix layer for file I/O operations. The library supports the complete GPX 1.1 specification including waypoints, routes, tracks, and metadata with strong type safety and validation."

     

       7
       7
       +
       maintainer: ["Anil Madhavapeddy <anil@recoil.org>"]

     

       7
       8
        
       authors: ["Anil Madhavapeddy"]

     

       8
       9
        
       license: "ISC"

     

       9
       10
        
       homepage: "https://tangled.sh/@anil.recoil.org/ocaml-gpx"

     

       11
       11
       +
       bug-reports: "https://tangled.sh/@anil.recoil.org/ocaml-gpx/issues"

     

       10
       12
        
       depends: [

     

       11
       13
        
         "ocaml"

     

       12
       14
        
         "dune" {>= "3.18"}

     

       13
       15
        
         "xmlm"

     

       14
       16
        
         "ptime"

     

       15
       15
       -
         "eio"

     

       17
       17
       +
         "eio" {>= "1.2"}

     

       16
       18
        
         "ppx_expect"

     

       17
       19
        
         "alcotest"

     

       18
       20
        
         "eio_main"

     
···

       36
       38
        
         ]

     

       37
       39
        
       ]

     

       38
       40
        
       x-maintenance-intent: ["(latest)"]

     

       41
       41
       +
       dev-repo: "git+https://tangled.sh/@anil.recoil.org/ocaml-gpx"

+1

mlgpx.opam.template

···

       1
       1
       +
       dev-repo: "git+https://tangled.sh/@anil.recoil.org/ocaml-gpx"

+5 -2

test/dune

···

       5
       5
        
        (modules test_gpx))

     

       6
       6
        
       

     

       7
       7
        
       ;; ppx_expect inline tests

     

       8
       8
       +
       

     

       8
       9
        
       (library

     

       9
       10
        
        (name test_corpus)

     

       10
       11
        
        (libraries gpx)

     

       11
       12
        
        (inline_tests)

     

       12
       12
       -
        (preprocess (pps ppx_expect))

     

       13
       13
       +
        (preprocess

     

       14
       14
       +
         (pps ppx_expect))

     

       13
       15
        
        (modules test_corpus))

     

       14
       16
        
       

     

       15
       17
        
       ;; Alcotest suite for Unix and Eio comparison

     

       18
       18
       +
       

     

       16
       19
        
       (executable

     

       17
       20
        
        (public_name corpus_test)

     

       18
       21
        
        (name test_corpus_unix_eio)

     

       19
       22
        
        (libraries gpx gpx_unix gpx_eio alcotest eio_main)

     

       20
       23
        
        (optional)

     

       21
       21
       -
        (modules test_corpus_unix_eio))
     

       24
       24
       +
        (modules test_corpus_unix_eio))

Compare changes