Function bodies 1,000 total

Name: Aljefra Mapper analysis
Creator: Repobility
License: https://repobility.com/legal/terms/

get_initials function · rust · L171-L185 (15 LOC)

crates/rinch-components/src/avatar.rs

    fn get_initials(&self) -> Option<String> {
        if self.name.is_empty() {
            None
        } else {
            Some(
                self.name
                    .split_whitespace()
                    .filter_map(|word| word.chars().next())
                    .take(2)
                    .collect::<String>()
                    .to_uppercase(),
            )
        }
    }

render function · rust · L189-L222 (34 LOC)

crates/rinch-components/src/avatar.rs

    fn render(&self, __scope: &mut RenderScope, _children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! { div { class: "rinch-avatar" } };
        container.set_attribute("class", &self.class_string());

        if !self.color.is_empty() {
            let c = &self.color;
            let style = if c.starts_with('#') || c.starts_with("rgb") || c.starts_with("hsl") {
                format!("--rinch-avatar-color: {}", c)
            } else {
                format!("--rinch-avatar-color: var(--rinch-color-{}-6)", c)
            };
            container.set_attribute("style", &style);
        }

        if !self.src.is_empty() {
            let src = &self.src;
            let alt = if self.alt.is_empty() { "" } else { &self.alt };
            let img = rinch_macros::rsx! { img { class: "rinch-avatar__image" } };
            img.set_attribute("src", src);
            img.set_attribute("alt", alt);
            container.append_child(&img);
        } else if le

render function · rust · L233-L248 (16 LOC)

crates/rinch-components/src/avatar.rs

    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! { div { class: "rinch-avatar-group" } };

        if !self.spacing.is_empty() {
            let spacing = &self.spacing;
            container.set_attribute(
                "style",
                &format!("--rinch-avatar-group-spacing: {}", spacing),
            );
        }

        for child in children {
            container.append_child(child);
        }
        container
    }

class_name function · rust · L24-L31 (8 LOC)

crates/rinch-components/src/badge.rs

    pub fn class_name(&self) -> &'static str {
        match self {
            BadgeVariant::Filled => "rinch-badge--filled",
            BadgeVariant::Light => "rinch-badge--light",
            BadgeVariant::Outline => "rinch-badge--outline",
            BadgeVariant::Dot => "rinch-badge--dot",
        }
    }

from_str function · rust · L36-L45 (10 LOC)

crates/rinch-components/src/badge.rs

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "filled" => Ok(BadgeVariant::Filled),
            "light" => Ok(BadgeVariant::Light),
            "outline" => Ok(BadgeVariant::Outline),
            "dot" => Ok(BadgeVariant::Dot),
            _ => Err(()),
        }
    }

class_name function · rust · L61-L69 (9 LOC)

crates/rinch-components/src/badge.rs

    pub fn class_name(&self) -> &'static str {
        match self {
            BadgeSize::Xs => "rinch-badge--xs",
            BadgeSize::Sm => "rinch-badge--sm",
            BadgeSize::Md => "rinch-badge--md",
            BadgeSize::Lg => "rinch-badge--lg",
            BadgeSize::Xl => "rinch-badge--xl",
        }
    }

from_str function · rust · L74-L84 (11 LOC)

crates/rinch-components/src/badge.rs

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "xs" => Ok(BadgeSize::Xs),
            "sm" => Ok(BadgeSize::Sm),
            "md" => Ok(BadgeSize::Md),
            "lg" => Ok(BadgeSize::Lg),
            "xl" => Ok(BadgeSize::Xl),
            _ => Err(()),
        }
    }

Open data scored by Repobility · https://repobility.com

class_string function · rust · L104-L129 (26 LOC)

crates/rinch-components/src/badge.rs

    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-badge"];

        // Size class
        let size: BadgeSize = if self.size.is_empty() {
            BadgeSize::default()
        } else {
            self.size.parse().unwrap_or_default()
        };
        classes.push(size.class_name());

        // Variant class
        let variant: BadgeVariant = if self.variant.is_empty() {
            BadgeVariant::default()
        } else {
            self.variant.parse().unwrap_or_default()
        };
        classes.push(variant.class_name());

        // Full width
        if self.full_width {
            classes.push("rinch-badge--full-width");
        }

        classes.join(" ")
    }

render function · rust · L133-L145 (13 LOC)

crates/rinch-components/src/badge.rs

    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! { span { class: "rinch-badge" } };
        container.set_attribute("class", &self.class_string());

        if !self.color.is_empty() {
            container.set_attribute("data-color", &self.color);
        }

        for child in children {
            container.append_child(child);
        }
        container
    }

class_string function · rust · L33-L52 (20 LOC)

crates/rinch-components/src/blockquote.rs

    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-blockquote"];

        if self.icon.is_some() {
            classes.push("rinch-blockquote--with-icon");
        }

        if !self.radius.is_empty() {
            classes.push(match self.radius.as_str() {
                "xs" => "rinch-blockquote--radius-xs",
                "sm" => "rinch-blockquote--radius-sm",
                "md" => "rinch-blockquote--radius-md",
                "lg" => "rinch-blockquote--radius-lg",
                "xl" => "rinch-blockquote--radius-xl",
                _ => "",
            });
        }

        classes.join(" ")
    }

render function · rust · L56-L95 (40 LOC)

crates/rinch-components/src/blockquote.rs

    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! { blockquote { class: "rinch-blockquote" } };
        container.set_attribute("class", &self.class_string());

        // Color style
        if !self.color.is_empty() {
            let c = &self.color;
            let style = if c.starts_with('#') || c.starts_with("rgb") || c.starts_with("hsl") {
                format!("--rinch-blockquote-color: {}", c)
            } else {
                format!("--rinch-blockquote-color: var(--rinch-color-{}-6)", c)
            };
            container.set_attribute("style", &style);
        }

        // Icon element
        if let Some(icon) = self.icon {
            let icon_wrapper = rinch_macros::rsx! { span { class: "rinch-blockquote__icon" } };
            let icon_el = render_tabler_icon(__scope, icon, TablerIconStyle::Outline);
            icon_wrapper.append_child(&icon_el);
            container.append_chil

class_name function · rust · L54-L63 (10 LOC)

crates/rinch-components/src/borderless_window.rs

    pub fn class_name(&self) -> &'static str {
        match self {
            WindowRadius::None => "rinch-borderlesswindow--radius-none",
            WindowRadius::Xs => "rinch-borderlesswindow--radius-xs",
            WindowRadius::Sm => "rinch-borderlesswindow--radius-sm",
            WindowRadius::Md => "rinch-borderlesswindow--radius-md",
            WindowRadius::Lg => "rinch-borderlesswindow--radius-lg",
            WindowRadius::Xl => "rinch-borderlesswindow--radius-xl",
        }
    }

from_str function · rust · L68-L79 (12 LOC)

crates/rinch-components/src/borderless_window.rs

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "none" | "0" => Ok(WindowRadius::None),
            "xs" => Ok(WindowRadius::Xs),
            "sm" => Ok(WindowRadius::Sm),
            "md" => Ok(WindowRadius::Md),
            "lg" => Ok(WindowRadius::Lg),
            "xl" => Ok(WindowRadius::Xl),
            _ => Err(()),
        }
    }

fmt function · rust · L118-L131 (14 LOC)

crates/rinch-components/src/borderless_window.rs

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BorderlessWindow")
            .field("title", &self.title)
            .field("radius", &self.radius)
            .field("show_minimize", &self.show_minimize)
            .field("show_maximize", &self.show_maximize)
            .field("show_close", &self.show_close)
            .field("left_section", &self.left_section.as_ref().map(|_| "..."))
            .field("right_section", &self.right_section.as_ref().map(|_| "..."))
            .field("on_minimize", &self.on_minimize.as_ref().map(|_| "..."))
            .field("on_maximize", &self.on_maximize.as_ref().map(|_| "..."))
            .field("on_close", &self.on_close.as_ref().map(|_| "..."))
            .finish()
    }

default function · rust · L135-L148 (14 LOC)

crates/rinch-components/src/borderless_window.rs

    fn default() -> Self {
        Self {
            title: String::new(),
            radius: String::new(),
            show_minimize: true,
            show_maximize: true,
            show_close: true,
            left_section: None,
            right_section: None,
            on_minimize: None,
            on_maximize: None,
            on_close: None,
        }
    }

Generated by Repobility's multi-pass static-analysis pipeline (https://repobility.com)

class_string function · rust · L153-L166 (14 LOC)

crates/rinch-components/src/borderless_window.rs

    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-borderlesswindow"];

        // Radius
        if !self.radius.is_empty() {
            if let Ok(r) = self.radius.parse::<WindowRadius>() {
                classes.push(r.class_name());
            }
        } else {
            classes.push(WindowRadius::default().class_name());
        }

        classes.join(" ")
    }

render function · rust · L30-L56 (27 LOC)

crates/rinch-components/src/breadcrumbs.rs

    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let separator = if self.separator.is_empty() {
            "/"
        } else {
            &self.separator
        };

        let nav = rinch_macros::rsx! { nav { class: "rinch-breadcrumbs" } };
        nav.set_attribute("aria-label", "Breadcrumb");

        if !self.separator_margin.is_empty() {
            nav.set_attribute(
                "style",
                &format!("--rinch-breadcrumbs-margin: {}", self.separator_margin),
            );
        }

        let ol = rinch_macros::rsx! { ol { class: "rinch-breadcrumbs__list" } };
        ol.set_attribute("data-separator", &html_escape(separator));

        for child in children {
            ol.append_child(child);
        }

        nav.append_child(&ol);
        nav
    }

render function · rust · L67-L87 (21 LOC)

crates/rinch-components/src/breadcrumbs.rs

    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let li = rinch_macros::rsx! { li { class: "rinch-breadcrumbs__item" } };

        let content = if !self.href.is_empty() {
            let link = rinch_macros::rsx! { a { class: "rinch-breadcrumbs__link" } };
            link.set_attribute("href", &self.href);
            for child in children {
                link.append_child(child);
            }
            link
        } else {
            let span = rinch_macros::rsx! { span { class: "rinch-breadcrumbs__item--active" } };
            for child in children {
                span.append_child(child);
            }
            span
        };

        li.append_child(&content);
        li
    }

html_escape function · rust · L89-L96 (8 LOC)

crates/rinch-components/src/breadcrumbs.rs

fn html_escape(s: &str) -> String {
    s.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&#39;")
}

class_name function · rust · L26-L34 (9 LOC)