regol 0.2.0

Independent GeoDesk GOL 2.0 reader and OSM PBF builder
Documentation
#![forbid(unsafe_code)]
use regol::{FeatureId, Geometry, Library, Result, source::Source};
use std::io;

struct Segments<'a> {
    bytes: &'a [u8],
    width: usize,
}
impl Source for Segments<'_> {
    fn len(&self) -> u64 {
        self.bytes.len() as u64
    }
    fn read_exact_at(&self, offset: u64, out: &mut [u8]) -> io::Result<()> {
        self.bytes.read_exact_at(offset, out)
    }
    fn segment(&self, offset: u64) -> io::Result<Option<(u64, &[u8])>> {
        let offset = usize::try_from(offset).map_err(|_| io::ErrorKind::UnexpectedEof)?;
        let start = offset / self.width * self.width;
        let end = start.saturating_add(self.width).min(self.bytes.len());
        let bytes = self
            .bytes
            .get(start..end)
            .ok_or(io::ErrorKind::UnexpectedEof)?;
        Ok(Some((start as u64, bytes)))
    }
}

fn shapes<S: Source>(library: Library<S>) -> Result<Vec<(FeatureId, Geometry)>> {
    library
        .features()
        .map(|feature| {
            let feature = feature?;
            Ok((feature.id(), feature.geometry()?))
        })
        .collect()
}

#[test]
fn owned_read_windows_preserve_geometry_and_prepared_query_results() -> Result<()> {
    use regol::Query;
    struct Buffered<'a>(Segments<'a>);
    impl Source for Buffered<'_> {
        fn len(&self) -> u64 {
            self.0.len()
        }
        fn read_buffer_size(&self) -> usize {
            self.0.width
        }
        fn read_exact_at(&self, offset: u64, out: &mut [u8]) -> io::Result<()> {
            self.0.read_exact_at(offset, out)
        }
    }
    let geometry = include_bytes!("fixtures/geometry.gol").as_slice();
    let expected_shapes = shapes(Library::new(geometry)?)?;
    let bytes = include_bytes!("fixtures/basic.gol").as_slice();
    let simple = Library::new(bytes)?;
    for width in [1, 7, 31, 4096] {
        assert_eq!(
            shapes(Library::new(Buffered(Segments {
                bytes: geometry,
                width
            }))?)?,
            expected_shapes
        );
        let buffered = Library::new(Buffered(Segments { bytes, width }))?;
        for text in [
            "*",
            "*[name]",
            "*[!name]",
            "na[amenity=cafe]",
            "*[value>=12]",
            "*[name][name]",
        ] {
            let query = Query::parse(text)?;
            let expected = simple
                .select(&query)
                .map(|f| f.map(|f| f.id()))
                .collect::<Result<Vec<_>>>()?;
            let actual = query
                .prepare(&buffered)?
                .iter()
                .map(|f| f.map(|f| f.id()))
                .collect::<Result<Vec<_>>>()?;
            assert_eq!(actual, expected, "buffer width={width}, query={text}");
            assert_eq!(query.prepare(&buffered)?.count()?, expected.len() as u64);
            let folded = query
                .prepare(&buffered)?
                .try_fold(Vec::new(), |mut ids, feature| {
                    ids.push(feature.id());
                    Ok(ids)
                })?;
            assert_eq!(folded, expected);
        }
    }
    Ok(())
}

#[test]
fn headers_and_geometry_agree_across_short_segments_and_fallbacks() -> Result<()> {
    let bytes = include_bytes!("fixtures/geometry.gol").as_slice();
    let expected = shapes(Library::new(bytes)?)?;
    assert!(!expected.is_empty());
    for width in [1, 7, 10, 11, 12, 13, 16, 20, 31, 32, 257] {
        let library = Library::new(Segments { bytes, width })?;
        assert_eq!(shapes(library)?, expected, "segment width={width}");
    }
    Ok(())
}

#[test]
fn spatial_windows_match_independent_feature_bounds_at_segment_edges() -> Result<()> {
    use regol::Bounds;
    let bytes = include_bytes!("fixtures/geometry.gol").as_slice();
    let library = Library::new(bytes)?;
    let records = library
        .features()
        .map(|feature| {
            let feature = feature?;
            Ok((feature.id(), feature.bounds()?))
        })
        .collect::<Result<Vec<_>>>()?;
    let mut windows = vec![Bounds::WORLD, Bounds::new(-1, -1, 1, 1)?];
    for &(_, bounds) in &records {
        windows.push(bounds);
        windows.push(Bounds::new(
            bounds.min.x,
            bounds.min.y,
            bounds.min.x,
            bounds.min.y,
        )?);
        windows.push(Bounds::new(
            bounds.max.x,
            bounds.max.y,
            bounds.max.x,
            bounds.max.y,
        )?);
    }
    for width in [1, 7, 8, 10, 11, 12, 13, 15, 16, 17, 20, 31, 32, 33, 257] {
        let library = Library::new(Segments { bytes, width })?;
        for &bounds in &windows {
            let mut expected: Vec<_> = records
                .iter()
                .filter(|(_, b)| bounds.intersects(*b))
                .map(|(id, _)| *id)
                .collect();
            let mut actual = library
                .in_bounds(bounds)
                .map(|f| f.map(|f| f.id()))
                .collect::<Result<Vec<_>>>()?;
            expected.sort_unstable();
            actual.sort_unstable();
            assert_eq!(actual, expected, "segment width={width}, bounds={bounds:?}");
        }
    }
    Ok(())
}

#[test]
fn dictionary_equality_crosses_record_and_tag_window_edges() -> Result<()> {
    use regol::Query;
    let bytes = include_bytes!("fixtures/stress.gol").as_slice();
    let reference = Library::new(bytes)?;
    let generic = Query::parse("na[amenity=cafe,cafe]")?;
    let expected = generic
        .prepare(&reference)?
        .iter()
        .map(|f| f.map(|f| f.id()))
        .collect::<Result<Vec<_>>>()?;
    assert!(!expected.is_empty());
    let query = Query::parse("na[amenity=cafe]")?;
    for width in [1, 7, 19, 20, 31, 32, 64, 4096] {
        let library = Library::new(Segments { bytes, width })?;
        let prepared = query.prepare(&library)?;
        let ids = prepared
            .iter()
            .map(|f| f.map(|f| f.id()))
            .collect::<Result<Vec<_>>>()?;
        assert_eq!(ids, expected, "segment width={width}");
        assert_eq!(prepared.count()?, expected.len() as u64);
    }
    Ok(())
}

#[test]
fn prepared_tag_queries_match_general_decoding_across_short_segments() -> Result<()> {
    use regol::{Predicate, Query, Selector, TagValue, Types};
    let bytes = include_bytes!("fixtures/basic.gol").as_slice();
    let library = Library::new(bytes)?;
    let mut queries = Vec::new();
    for feature in library.features() {
        let mut keys = Vec::new();
        for tag in feature?.tags()? {
            let tag = tag?;
            keys.push(tag.key.to_string());
            queries.push(Query::new(
                Selector::new(Types::ALL).and(Predicate::truthy(tag.key.as_ref())),
            ));
            queries.push(Query::new(
                Selector::new(Types::ALL).and(Predicate::falsy(tag.key.as_ref())),
            ));
            let predicate = match tag.value {
                TagValue::Text(value) => Predicate::equal(tag.key.as_ref(), value.as_ref()),
                value => Predicate::equal_number(tag.key.as_ref(), value.as_number().unwrap())?,
            };
            queries.push(Query::new(Selector::new(Types::ALL).and(predicate)));
        }
        for pair in keys.windows(2) {
            for (first, second) in [(&pair[0], &pair[1]), (&pair[1], &pair[0])] {
                queries.push(Query::new(
                    Selector::new(Types::ALL)
                        .and(Predicate::truthy(first))
                        .and(Predicate::truthy(second)),
                ));
                queries.push(Query::new(
                    Selector::new(Types::ALL)
                        .and(Predicate::truthy(first))
                        .and(Predicate::falsy("gol_reader_missing_test_key"))
                        .and(Predicate::truthy(second)),
                ));
            }
        }
    }
    assert!(!queries.is_empty());
    let expected: Vec<Vec<_>> = queries
        .iter()
        .map(|query| {
            library
                .select(query)
                .map(|f| f.map(|f| f.id()))
                .collect::<Result<_>>()
        })
        .collect::<Result<_>>()?;
    for width in [1, 2, 3, 7, 8, 15, 16, 17, 31, 32, 33, 257] {
        let library = Library::new(Segments { bytes, width })?;
        for (query, expected) in queries.iter().zip(&expected) {
            let actual = query
                .prepare(&library)?
                .iter()
                .map(|f| f.map(|f| f.id()))
                .collect::<Result<Vec<_>>>()?;
            assert_eq!(&actual, expected, "segment width={width}, query={query:?}");
        }
    }
    Ok(())
}