This is the entry point for kamal as a production web server.
It exposes a single `-main` function that can be called through
the command line (after uberjar compilation) as java -jar ...

The main function reads the environment variables and uses them
to build and run the system configuration

As a convention we treat UPPERCASE names as environmental variables
and lowercase names as custom created keywords

Tools for interactive development with the REPL.

WARNING:
  This file should NOT be included in a production build of the application

WARNNING:
  using (refresh!) will fail if you just ran `lein uberjar`
  without cleaning afterwards.
  https://stackoverflow.com/questions/44246924/clojure-tools-namespace-refresh-fails-with-no-namespace-foo

parse the Markdown GTFS spec definition and returns it as Clojure data structures.

Uses several heuristics to guess how to interpret the data.

Useful to avoid monkey patching

namespace for hand-optimized queries that are used inside the routing
algorithm and need to run extremely fast (< 1 ms per query)

By convention all queries here return Entities

useful functions that have not found a proper place yet

An implementation of the Graph protocols oriented towards
Road Networks. See Graph namespace for more information

namespace for parsing a GTFS feed into a Datascript transaction.

The algorithms coerces GTFS csv files into entities that reference
each other through IDs. The IDs are taken directly from GTFS.

A small dynamic renaming is performed to make it more compatible
with Datascript design. The renaming is based on the GTFS naming
convention, for example: stop_lon, stop_url, trip_id, trip_headsign, etc.

We transform those strings into: :stop/lon, :stop/url, :trip/id,
:trip/headsign.

This is important to be able to create relationships between entities through
transactions, for example {:trip/id 1, :trip/route [:route/id 1]}. This
allows us to create relationships between entities without actually having
them, i.e. thread them simply as data

collection of functions to provide routing directions based on Open Street
Maps and General Transit Feed Specification data. It follows (as close
as possible) the MapBox v5 directions specification.

The algorithm provides a single route between the first and last coordinate.
It works as follows:
- create a Dijkstra collection to find the shortest path
- take the sequence and split it into 'pieces'
 - each piece is a subsection of the complete route with a common 'context'.
  The 'context' is the road name or the stop name
- loop over the pieces to create instructions based on each previous, current
  and next piece

collection of functions related to the use of GTFS feed on routing
networks.