Walkers

Hypermocker is an HTTP mocking library designed for async programming. It uses an 'anticipate' pattern to handle requests.

By default, Hypermocker will panic if an unanticipated request is made to the server. To prevent this, use the anticipate function to register a specific path.

Unlike traditional mock servers, an anticipated request does not respond immediately. Instead, the request remains in an active state, allowing you to perform other asynchronous tasks before manually triggering the response using request.respond().

tokio_test::block_on(async {
    // Bind HTTP server to random, free port.
    let server = hypermocker::Server::bind().await;

    // Tell the server not to panic on such request.
    let mut request = server.anticipate("/api/article").await;

    // Do some work, while HTTP request remains in progress.
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    // Send the response.
    request.respond(b"hello").await;
});

Walkers is a slippy maps widget for egui. To implement a map, you need to manage three main objects:

1. Tiles: Handles downloading and caching images from a tile provider (e.g., HttpTiles).
2. MapMemory: Maintains the internal state of the map widget.
3. Map: The actual egui widget used in your ui loop.

To initialize, use HttpTiles::new(source, egui_ctx) where source is a provider like OpenStreetMap. Use lon_lat(longitude, latitude) to set the initial position.

use walkers::{HttpTiles, Map, MapMemory, Position, sources::OpenStreetMap, lon_lat};
use egui::{Context, CentralPanel};
use eframe::{App, Frame};

struct MyApp {
    tiles: HttpTiles,
    map_memory: MapMemory,
}

impl MyApp {
    fn new(egui_ctx: Context) -> Self {
        Self {
            tiles: HttpTiles::new(OpenStreetMap, egui_ctx),
            map_memory: MapMemory::default(),
        }
    }
}

impl App for MyApp {
    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut Frame) {
        ui.add(Map::new(
            Some(&mut self.tiles),
            &mut self.map_memory,
            lon_lat(17.03664, 51.09916)
        ));
    }
}

The wanderers package provides a Journal system for tracking locations using a GeoJSON-based storage format.

• Place: Represents a single location. It contains a position (using walkers::Position), a name (String), and preserves any additional GeoJSON properties in an unknown_properties field to ensure data is not lost during load-save cycles.
• Journal: A collection of Place objects associated with a specific file path. It handles loading from and saving to the filesystem.

The journal format is a GeoJSON FeatureCollection of Point features. Non-point features (like lines or polygons) are automatically skipped during loading.

use wanderers::{Journal, Place};
use walkers::{lon_lat, Position};

// Create a new place
let position = lon_lat(17.0321, 51.1101);
let place = Place::new(position, "Rynek");

// Initialize a journal at a specific path
let journal = Journal {
    path: "my_journal.geojson".into(),
    places: vec![place],
};

// Save to disk
journal.save().expect("Failed to save journal");

// Load from disk
let loaded_journal = Journal::load("my_journal.geojson").expect("Failed to load journal");

The Center enum manages how the map is positioned relative to a reference point (typically a GPS location, referred to as my_position). The map can exist in several states:

• MyPosition: The default state. The map is centered exactly on the my_position provided to Map::new(). In this state, the map is 'attached' to the user's location.
• Exact(AdjustedPosition): The map is centered at a specific, fixed position that is not necessarily my_position.
• Moving { position, velocity, from_detached }: The map is currently being actively dragged by a user gesture.
• Inertia { position, velocity }: The user has released the drag, but the map continues to move due to simulated inertia.
• PulledToMyPosition(AdjustedPosition): A transitional state where the map is being automatically animated back toward my_position because the user released the drag while the map was still relatively close to the reference point.

When a user drags the map, it becomes "detached" from my_position. It remains detached until the user or application explicitly changes the MapMemory::center_mode back to Center::MyPosition.

To mock a specific endpoint, use Server::anticipate(url). This returns an AnticipatedRequest object. You must provide a response for every anticipated request, or the server will panic when dropped if unexpected requests occur.

There are two main ways to handle an AnticipatedRequest:

1. Provide a response: Use .respond(payload) or .respond_with_status(status) to define what the server should return when the request arrives.
2. Wait for the request: Use .expect() to asynchronously wait until the actual HTTP request is received by the server. This is useful for verifying that a client actually made the call.

// 1. Anticipate a request
let mut anticipated = server.anticipate("/api/data").await;

// 2. Define the response (e.g., with a body)
anticipated.respond(b"{\"status\":\"ok\"}").await;

// 3. (Optional) Wait for the request to actually happen in the client
let request = anticipated.expect().await;
println!("Received request to: {}", request.uri());