Librsvg

https://gnome.pages.gitlab.gnome.org/librsvg/
Admin
Librsvg is a C/Rust library for loading and rendering SVG documents with support for CSS styling and...
Tokens:2,528,995
Snippets:18,951
Trust Score:10
Update:6 days ago
Show doc for...
Tokens:
Raw
### Test module setup

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/color.rs.html

Starts the test module for color parsing and normalization tests.

```rust
#[cfg(test)]
mod tests {
    use super::*;

```

--------------------------------

### Example for first() method

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Example from the Rust documentation for the first() method on slices, showing how to get the first element.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Example for first_chunk() method

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Example from the Rust documentation for the first_chunk() method on slices, showing how to get the first N items as an array.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### Example for get() method

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Example from the Rust documentation for the get() method on slices, showing how to get an element or subslice by index or range.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Run podman container and set up environment

Source: https://gnome.pages.gitlab.gnome.org/librsvg/devel-docs/devel_environment.html

Commands to run the container and source the environment setup scripts. The first command starts an interactive shell, and the next two make Rust available and adjust environment variables.

```bash
podman run --rm -ti --cap-add=SYS_PTRACE -v $(pwd):/srv/project:z -w /srv/project $image_name
```

```bash
source ci/env.sh
source ci/setup-dependencies-env.sh
```

--------------------------------

### Basic compilation commands for a tarball build

Source: https://gnome.pages.gitlab.gnome.org/librsvg/devel-docs/_sources/compiling.rst.txt

Use these commands to compile and install librsvg from a tarball. The meson setup command enables documentation, introspection, and Vala bindings. The -D options are described in the compile-time options section.

```sh
mkdir -p _build
meson setup _build -Ddocs=enabled -Dintrospection=enabled -Dvala=enabled
meson compile -C _build
meson install -C _build
```

--------------------------------

### starts_with example: check prefix

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Shows how to use slice.starts_with to check if a slice starts with a given prefix.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

--------------------------------

### PaintServer Test Module Setup

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/paint_server.rs.html

Initial setup for the paint server test module.

```rust
#[cfg(test)]
mod tests {
    use super::*;

    use crate::color::RGBA;
```

--------------------------------

### Example for Option::as_slice

Source: https://gnome.pages.gitlab.gnome.org/librsvg/doc/librsvg_rebind_sys/type.RsvgSizeFunc.html

Shows how to get a slice from an Option, and the inverse relationship with slice::first.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);
```

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}
```

--------------------------------

### Main Entry Point

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/src/rsvg_bench/main.rs.html

Initializes the CLI, parses arguments, validates input, and executes the benchmark run.

```rust
fn main() {
    let cli = build_cli();

    let matches = cli.get_matches();

    let sleep_secs = matches
        .get_one("sleep")
        .copied()
        .expect("already provided default_value");
    let num_parse = matches
        .get_one("num-parse")
        .copied()
        .expect("already provided default_value");
    let num_render = matches
        .get_one("num-render")
        .copied()
        .expect("already provided default_value");
    let hard_failures = matches.get_flag("hard-failures");

    let inputs = if let Some(inputs) = matches.get_many("inputs") {
        inputs.cloned().collect()
    } else {
        eprintln!("Must specify at least one SVG file or directory to process\n");
        process::exit(1);
    };

    let opt = Opt {
        sleep_secs,
        num_parse,
        num_render,
        hard_failures,
        inputs,
    };

    if opt.num_parse < 1 {
        eprintln!("Must parse files at least 1 time; please specify a higher number\n");
        process::exit(1);
    }

    println!("hard_failures: {:?}", opt.hard_failures);

    match run(&opt) {
        Ok(_) => (),
        Err(e) => {
            eprintln!("{e}");
            process::exit(1);
        }
    }
}
```

--------------------------------

### Setup for multiple closed subpaths

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/marker.rs.html

Builds two closed subpaths and returns their segments. Each subpath gets a closing line back to its start.

```rust
fn setup_multiple_closed_subpaths() -> Segments {
    let mut builder = PathBuilder::default();

    builder.move_to(10.0, 10.0);
    builder.line_to(20.0, 10.0);
    builder.line_to(20.0, 20.0);
    builder.close_path();

    builder.move_to(30.0, 30.0);
    builder.line_to(40.0, 30.0);
    builder.curve_to(50.0, 35.0, 60.0, 60.0, 70.0, 70.0);
    builder.line_to(80.0, 90.0);
    builder.close_path();

    Segments::from(&builder.into_path())
}
```

--------------------------------

### Full build and test with Meson

Source: https://gnome.pages.gitlab.gnome.org/librsvg/devel-docs/_sources/contributing.rst.txt

Commands to set up a full build with documentation, introspection, and Vala bindings, then compile and run the full test suite.

```sh
mkdir -p _build
meson setup _build -Ddocs=enabled -Dintrospection=enabled -Dvala=enabled
meson compile -C _build
meson test -C _build
```

--------------------------------

### Example for last() method

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Example from the Rust documentation for the last() method on slices, showing how to get the last element.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Podman run instructions from pull-container-image.sh

Source: https://gnome.pages.gitlab.gnome.org/librsvg/devel-docs/_sources/devel_environment.rst.txt

Output from the pull-container-image.sh script showing how to run the container and set up the environment inside it.

```text
You can now run this:
  podman run --rm -ti --cap-add=SYS_PTRACE -v $(pwd):/srv/project:z -w /srv/project $image_name

Don't forget to run this once inside the container:
  source ci/env.sh
  source ci/setup-dependencies-env.sh
```

--------------------------------

### Build and install librsvg for rebind publishing

Source: https://gnome.pages.gitlab.gnome.org/librsvg/devel-docs/_sources/releasing.rst.txt

The publish process for librsvg-rebind needs the .so installed to build, so run these commands first.

```shell
meson setup _build --prefix /usr/local/librsvg && meson compile -C _build && meson install -C _build
```

--------------------------------

### Example for len() method

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Example from the Rust documentation for the len() method on slices, showing how to get the number of elements.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### windows example with short slice

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows that `windows` returns no values when the slice is shorter than the window size.

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

--------------------------------

### Example for last_chunk() method

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/marker/struct.Segments.html

Example from the Rust documentation for the last_chunk() method on slices, showing how to get the last N items as an array.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

--------------------------------

### Option::iter example

Source: https://gnome.pages.gitlab.gnome.org/librsvg/doc/librsvg_rebind_sys/type.RsvgSizeFunc.html

Shows how to use Option::iter to get an iterator over the contained value. The example asserts that iterating over None yields no items.

```rust
let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);
```

--------------------------------

### C API Test Setup and Includes

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/librsvg-c/tests-c/api.c.html

Initial setup for the C API tests, including necessary headers and disabling deprecation warnings to test legacy API components.

```c
/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
```

```c
/* vim: set ts=4 nowrap ai expandtab sw=4: */
```

```c
/* These are the C API tests for librsvg.  These test the complete C
 * API, especially its historical peculiarities to ensure ABI
 * compatibility.
 *
 * These tests are not meant to exhaustively test librsvg's features.
 * For those, you should look at the Rust integration tests.  See
 * tests/README.md for details.
 */
```

```c
#include <stdio.h>
#include <glib.h>
#include <cairo.h>

#define RSVG_DISABLE_DEPRECATION_WARNINGS /* so we can test deprecated API */
#include <librsvg/rsvg.h>
#include "test-utils.h"
```

```c
/*
  Untested:
  rsvg_handle_internal_set_testing
*/
```

--------------------------------

### Get DPI Y function signature

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/librsvg-c/src/handle.rs.html

Starts the definition of the get_dpi_y method.

```rust
        fn get_dpi_y(&self) -> f64 {

```

--------------------------------

### utf8_cstr_len

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/util.rs.html

Gets a known-to-be valid UTF-8 string given a pointer to its start and a length.

```APIDOC
## utf8_cstr_len

### Description
Gets a known-to-be valid UTF-8 string given a pointer to its start and a length.

### Function Signature
```rust
pub unsafe fn utf8_cstr_len<'a>(start: *const libc::c_char, len: usize) -> &'a str
```

### Safety
`start` must be a valid pointer, and `len` bytes starting from it must be valid UTF-8.

### Parameters
- `start` (*const libc::c_char) - Pointer to the start of the UTF-8 string.
- `len` (usize) - Number of bytes to include in the string slice.

### Returns
- `&'a str` - A string slice referencing `len` bytes starting at `start`.

### Example
```rust
let bytes = b"hello";
let start = bytes.as_ptr() as *const libc::c_char;
let s = unsafe { utf8_cstr_len(start, bytes.len()) };
assert_eq!(s, "hello");
```
```

--------------------------------

### Option::reduce examples

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/librsvg_c/handle/type.RsvgSizeFunc.html

Shows how to use Option::reduce with a function f and a fallback value n. The examples demonstrate reducing Some and None combinations.

```rust
assert_eq!(s12.reduce(s17, f), Some(29));
assert_eq!(s12.reduce(n, f), Some(12));
assert_eq!(n.reduce(s17, f), Some(17));
assert_eq!(n.reduce(n, f), None);
```

--------------------------------

### utf8_cstr_bounds

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/util.rs.html

Gets a known-to-be valid UTF-8 string given start and end-exclusive pointers to its bounds.

```APIDOC
## utf8_cstr_bounds

### Description
Gets a known-to-be valid UTF-8 string given start and end-exclusive pointers to its bounds.

### Function Signature
```rust
pub unsafe fn utf8_cstr_bounds<'a>(
    start: *const libc::c_char,
    end: *const libc::c_char,
) -> &'a str
```

### Safety
`start` must be a valid pointer, and `end` must be the same for a zero-length string, or greater than `start`. All the bytes between them must be valid UTF-8.

### Parameters
- `start` (*const libc::c_char) - Pointer to the start of the UTF-8 string.
- `end` (*const libc::c_char) - Pointer to one past the end of the UTF-8 string.

### Returns
- `&'a str` - A string slice referencing the bytes between `start` and `end`.

### Example
```rust
let bytes = b"hello";
let start = bytes.as_ptr() as *const libc::c_char;
let end = unsafe { start.add(bytes.len()) };
let s = unsafe { utf8_cstr_bounds(start, end) };
assert_eq!(s, "hello");
```
```

--------------------------------

### Test module imports and setup

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/css.rs.html

This snippet shows the beginning of the test module, including imports and the use of the selectors::Element trait.

```rust
#[cfg(test)]
mod tests {
    use super::*;
    use selectors::Element;

    use crate::document::Document;
    use crate::is_element_of_type;

```

--------------------------------

### Example for Option::as_ref

Source: https://gnome.pages.gitlab.gnome.org/librsvg/doc/librsvg_rebind_sys/type.RsvgSizeFunc.html

Shows how to use as_ref to avoid moving the original Option when using map.

```rust
let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");
```

--------------------------------

### url::Url::path() example

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/url_resolver/struct.AllowedUrl.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the path as a percent-encoded ASCII string. For cannot-be-a-base URLs, it returns an arbitrary string not starting with '/'. For other URLs, it starts with '/' and contains slash-separated segments.

```rust
use url::{Url, ParseError};

let url = Url::parse("https://example.com/api/versions?page=2")?;
assert_eq!(url.path(), "/api/versions");

let url = Url::parse("https://example.com")?;
assert_eq!(url.path(), "/");

let url = Url::parse("https://example.com/countries/việt nam")?;
assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
```

--------------------------------

### Test module setup

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/pattern.rs.html

Sets up the test module with necessary imports and the module declaration.

```rust
#[cfg(test)]
```

```rust
mod tests {
```

```rust
use super::*;
```

```rust
use markup5ever::{QualName, ns};
```

```rust
use crate::borrow_element_as;
```

```rust
use crate::node::NodeData;
```

--------------------------------

### Test Module Setup

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/cairo_path.rs.html

Sets up the test module with imports and the PathBuilder dependency.

```rust
#[cfg(test)]

```

```rust
mod tests {

```

```rust
    use super::*;

```

```rust
    use crate::path_builder::PathBuilder;

```

--------------------------------

### Comment: Tests for deprecated APIs to get geometries

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/librsvg-c/tests-c/api.c.html

A comment indicating the start of tests for deprecated geometry APIs.

```c
/* Tests for the deprecated APIs to get geometries */
```

--------------------------------

### Test Module Setup

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/src/rsvg/surface_utils/shared_surface.rs.html

Initializes the test module for the surface utilities.

```rust
#[cfg(test)]
mod tests {
    use super::*;
```

--------------------------------

### Setup for closed subpath

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/marker.rs.html

Builds a single closed subpath and returns its segments. The close_path adds a line back to the start.

```rust
fn setup_closed_subpath() -> Segments {
    let mut builder = PathBuilder::default();

    builder.move_to(10.0, 10.0);
    builder.line_to(20.0, 10.0);
    builder.line_to(20.0, 20.0);
    builder.close_path();

    Segments::from(&builder.into_path())
}
```

--------------------------------

### Initialize test framework: g_test_init

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/librsvg-c/tests-c/api.c.html

Initializes the GLib test framework.

```c
    g_test_init (&argc, &argv, NULL);
```

--------------------------------

### port method examples

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/url_resolver/struct.AllowedUrl.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use `Url::port()` to get the port number. Default ports are not reflected; use `port_or_known_default()` for that.

```rust
use url::Url;

let url = Url::parse("https://example.com")?;
assert_eq!(url.port(), None);

let url = Url::parse("https://example.com:443/")?;
assert_eq!(url.port(), None);

let url = Url::parse("ssh://example.com:22")?;
assert_eq!(url.port(), Some(22));
```

--------------------------------

### Setup for no moveto after closepath

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/rsvg/src/marker.rs.html

Builds a path where a lineto follows a closed subpath without a moveto. The lineto starts from the first point of the first subpath.

```rust
fn setup_no_moveto_after_closepath() -> Segments {
    let mut builder = PathBuilder::default();

    builder.move_to(10.0, 10.0);
    builder.line_to(20.0, 10.0);
    builder.line_to(20.0, 20.0);
    builder.close_path();

    builder.line_to(40.0, 30.0);

    Segments::from(&builder.into_path())
}
```

--------------------------------

### Option::take example

Source: https://gnome.pages.gitlab.gnome.org/librsvg/doc/librsvg_rebind_sys/type.RsvgSizeFunc.html

Shows how to take the value out of an option, leaving None in its place.

```rust
let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);
```

--------------------------------

### iter example

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/check_rsvg_convert_options/type.UnitResult.html

Shows how to use Result::iter to get an iterator over the possibly contained value, yielding one value if Ok and none if Err.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### Option::or example

Source: https://gnome.pages.gitlab.gnome.org/librsvg/doc/librsvg_rebind_sys/type.RsvgSizeFunc.html

Demonstrates Option::or returning the option if it contains a value, otherwise returning the second option. The examples cover all combinations of Some and None.

```rust
let x = Some(2);
let y = None;
assert_eq!(x.or(y), Some(2));

let x = None;
let y = Some(100);
assert_eq!(x.or(y), Some(100));

let x = Some(2);
let y = Some(100);
assert_eq!(x.or(y), Some(2));

let x: Option<u32> = None;
let y = None;
assert_eq!(x.or(y), None);
```

--------------------------------

### port_or_known_default method examples

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/url_resolver/struct.AllowedUrl.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use `Url::port_or_known_default()` to get the port number or the default for known schemes (`http`, `https`, `ws`, `wss`, `ftp`).

```rust
use url::Url;

let url = Url::parse("foo://example.com")?;
assert_eq!(url.port_or_known_default(), None);

let url = Url::parse("foo://example.com:1456")?;
assert_eq!(url.port_or_known_default(), Some(1456));

let url = Url::parse("https://example.com")?;
assert_eq!(url.port_or_known_default(), Some(443));
```

--------------------------------

### LoadState::Start arm

Source: https://gnome.pages.gitlab.gnome.org/librsvg/coverage/librsvg-c/src/handle.rs.html

Handles the Start state.

```rust
                LoadState::Start => (),

```

--------------------------------

### Get user's preferred locale from environment (locale_from_environment)

Source: https://gnome.pages.gitlab.gnome.org/librsvg/doc/src/rsvg/accept_language.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Builds a Locale from glib::language_names(), adding each name as a LanguageRange if it parses successfully. Starts with an invariant locale.

```rust
fn locale_from_environment() -> Locale {
    let mut locale = Locale::invariant();

    for name in glib::language_names() {
        let name = name.as_str();
        if let Ok(range) = LanguageRange::from_unix(name) {
            locale.add(&range);
        }
    }

    locale
}
```

--------------------------------

### host method examples

Source: https://gnome.pages.gitlab.gnome.org/librsvg/internals/rsvg/url_resolver/struct.AllowedUrl.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use `Url::host()` to get the parsed host representation. Returns `None` for URLs without a host, such as `unix:` and `data:` URLs.

```rust
use url::Url;

let url = Url::parse("https://127.0.0.1/index.html")?;
assert!(url.host().is_some());

let url = Url::parse("ftp://rms@example.com")?;
assert!(url.host().is_some());

let url = Url::parse("unix:/run/foo.socket")?;
assert!(url.host().is_none());

let url = Url::parse("data:text/plain,Stuff")?;
assert!(url.host().is_none());
```
Tokens:
Raw