Long hashes and state addresses in change titles are shown by their ends 62cdf34daec1

/// A bump change's message: its title names the upstream state by its

/// first head and head count, so a state of many heads does not make it

/// run on (oxygenhub#216); the whole address is in the body.

pub fn bump_message(path: &str, upstream: &str, heads: &[String]) -> String {

    let first = heads.first().map(String::as_str).unwrap_or("");

    match heads.len() {

        0 | 1 => format!("Diffusion: move {path} to {upstream} {first}"),

        n => format!("Diffusion: move {path} to {upstream} {first} (+{} heads)\n\nPins {upstream} at {}", n - 1, heads.join("+")),

    }

}

    let message = bump_message(&p, &upstream_label, &short);

    }

}

#[cfg(test)]

mod message_tests {

    use super::bump_message;

    #[test]

    fn a_bump_of_many_heads_has_a_short_title_and_the_whole_address_below() {

        let heads: Vec<String> = (0..20).map(|i| format!("{i:02x}a6c9d4746a")).collect();

        let m = bump_message("rstar-api", "doomsdayone/rstar-api", &heads);

        let (title, body) = m.split_once("\n\n").unwrap();

        assert_eq!(title, "Diffusion: move rstar-api to doomsdayone/rstar-api 00a6c9d4746a (+19 heads)");

        assert_eq!(body, format!("Pins doomsdayone/rstar-api at {}", heads.join("+")));

        assert_eq!(bump_message("api", "andy/api", &heads[..1]), "Diffusion: move api to andy/api 00a6c9d4746a");

/// Text with every long hash or state address in it (heads joined by `+`)

/// shown by its two ends and head count, the whole in a tip on hover or

/// focus (oxygenhub#216, as #198 did for a lone hash); the rest escaped.

pub fn addresses(value: &str, _: &dyn askama::Values) -> askama::Result<askama::filters::Safe<String>> {

    Ok(askama::filters::Safe(shorten_addresses(value)))

}

fn escape(s: &str) -> String {

    let mut out = String::with_capacity(s.len());

    for c in s.chars() {

        match c {

            '&' => out.push_str("&"),

            '<' => out.push_str("&lt;"),

            '>' => out.push_str(">"),

            '"' => out.push_str("""),

            '\'' => out.push_str("'"),

            c => out.push(c),

        }

    }

    out

}

/// Whether a word is a hash or state address: hex parts of 8 or more

/// joined by `+`, longer than [`cut_ends`] leaves alone.

fn is_address(word: &str) -> bool {

    word.chars().count() > 24 && word.split('+').all(|p| p.len() >= 8 && p.chars().all(|c| c.is_ascii_hexdigit()))

}

pub fn shorten_addresses(text: &str) -> String {

    let mut out = String::with_capacity(text.len());

    let mut word = String::new();

    let flush = |word: &mut String, out: &mut String| {

        // Trailing punctuation stays outside the address.

        let core = word.trim_end_matches(['.', ',', ';', ':', ')']);

        if is_address(core) {

            let heads = core.split('+').count();

            let count = if heads > 1 { format!(" ({heads} heads)") } else { String::new() };

            let full = escape(core);

            out.push_str(&format!(

                "<span class=\"hash-tip\" tabindex=\"0\" data-full=\"{full}\" aria-label=\"{full}\">{}{count}</span>",

                escape(&cut_ends(core))

            ));

            out.push_str(&escape(&word[core.len()..]));

        } else {

            out.push_str(&escape(word));

        }

        word.clear();

    };

    for c in text.chars() {

        if c.is_whitespace() || c == '(' {

            flush(&mut word, &mut out);

            out.push_str(&escape(&c.to_string()));

        } else {

            word.push(c);

        }

    }

    flush(&mut word, &mut out);

    out

}

    }

}

#[cfg(test)]

mod address_tests {

    use super::shorten_addresses;

    #[test]

    fn long_addresses_in_text_are_shown_by_their_ends() {

        let heads: Vec<String> = (0..20).map(|i| format!("{i:02x}a6c9d4746a")).collect();

        let address = heads.join("+");

        let out = shorten_addresses(&format!("Diffusion: move rstar-api to doomsdayone/rstar-api {address}."));

        assert!(out.starts_with("Diffusion: move rstar-api to doomsdayone/rstar-api <span class=\"hash-tip\""), "{out}");

        assert!(out.contains("(20 heads)</span>.") && out.contains(&format!("data-full=\"{address}\"")), "{out}");

        assert!(out.contains(">00a6c9d4…a6c9d4746a (20 heads)<") || out.contains("…"), "{out}");

        // A short hash, words and markup are left (escaped) as they are.

        assert_eq!(shorten_addresses("fix <b> in 02a6c9d4746a"), "fix &lt;b&gt; in 02a6c9d4746a");

        let one = "02a6c9d4746a1ac2fb7fa2f8e79a3356";

        assert!(shorten_addresses(one).contains(">02a6c9d4…e79a3356</span>"));

        assert_eq!(shorten_addresses("deadbeefdeadbeefdeadbeefdeadbeef-not"), "deadbeefdeadbeefdeadbeefdeadbeef-not");

    // (The bump's own runs finishing may still propose again, as Diffusion

    // does on an upstream's moves; the reconciler itself opens nothing.)

    assert_eq!(r.caught_up, 0, "the reconciler respects the closed bump: {r:?}");

  <div class="head"><h1>{{ c.view.title|addresses }} <small class="px">{{ c.view.short }}</small>{% if c.view.resolution %} <span class="tag" title="Resolves conflicts; depends on every change that wrote a side">resolution</span>{% endif %}</h1></div>

    <span class="small mute">{{ f.size|bytes }}{% if let Some(l) = language %} · {{ l }}{% endif %}{% if f.exec %} · executable{% endif %}{% if f.kind == crate::repos::view::EntryKind::Symlink %} · symlink{% endif %}{% if f.kind == crate::repos::view::EntryKind::Subrepo %} · subrepository pin{% endif %}{% if let Some(c) = f.last_change %} · last changed <a href="{{ repo.url }}/change/{{ c.hash }}">{{ c.title|addresses }}</a> {{ c.when_ms|ago }}{% endif %}</span>

    <a class="title" href="{{ repo.url }}/change/{{ c.hash }}">{{ c.title|addresses }}</a>

/* Nothing unbroken in a change row may push it wider than its card (#216). */

.chg-main { min-width: 0; overflow-wrap: anywhere; }