Function bodies 141 total

next function · rust · L20-L25 (6 LOC)

src/app.rs

    pub fn next(self) -> Self {
        match self {
            Panel::Running => Panel::Available,
            Panel::Available => Panel::Running,
        }
    }

prev function · rust · L28-L30 (3 LOC)

src/app.rs

    pub fn prev(self) -> Self {
        self.next()
    }

new function · rust · L44-L54 (11 LOC)

src/app.rs

    pub fn new(args: &Args) -> Self {
        Self {
            running: true,
            refresh_interval: args.refresh,
            ollama_state: OllamaState::default(),
            focused_panel: Panel::Running,
            running_table_state: TableState::default(),
            catalog_table_state: TableState::default(),
            show_help: false,
        }
    }

quit function · rust · L55-L58 (4 LOC)

src/app.rs

    pub fn quit(&mut self) {
        self.running = false;
    }

clamp_selections function · rust · L59-L78 (20 LOC)

src/app.rs

    pub(crate) fn clamp_selections(&mut self) {
        let running_len = self.ollama_state.running.len();
        let local_len = self.ollama_state.local.len();

        if let Some(i) = self.running_table_state.selected() {
            if running_len == 0 {
                self.running_table_state.select(None);
            } else if i >= running_len {
                self.running_table_state.select(Some(running_len - 1));
            }
        }
        if let Some(i) = self.catalog_table_state.selected() {
            if local_len == 0 {
                self.catalog_table_state.select(None);
            } else if i >= local_len {
                self.catalog_table_state.select(Some(local_len - 1));
            }
        }
    }

handle_event function · rust · L79-L148 (70 LOC)

src/app.rs

    pub fn handle_event(&mut self, event: Event) -> Action {
        match event {
            Event::Key(key) => {
                // Help overlay captures '?' to toggle and Esc to close
                if self.show_help {
                    match key.code {
                        KeyCode::Char('?') | KeyCode::Esc => self.show_help = false,
                        KeyCode::Char('q') => self.quit(),
                        KeyCode::Char('c')
                            if key.modifiers.contains(KeyModifiers::CONTROL) =>
                        {
                            self.quit();
                        }
                        _ => {}
                    }
                    return Action::None;
                }

                match key.code {
                    KeyCode::Char('q') => {
                        self.quit();
                        Action::None
                    }
                    KeyCode::Char('c')
                        if key.modifiers.contains(Ke

active_table_state function · rust · L149-L161 (13 LOC)

src/app.rs

    fn active_table_state(&mut self) -> (&mut TableState, usize) {
        match self.focused_panel {
            Panel::Running => (
                &mut self.running_table_state,
                self.ollama_state.running.len(),
            ),
            Panel::Available => (
                &mut self.catalog_table_state,
                self.ollama_state.local.len(),
            ),
        }
    }

Provenance: Repobility (https://repobility.com) — every score reproducible from /scan/

scroll_down function · rust · L162-L173 (12 LOC)

src/app.rs

    fn scroll_down(&mut self) {
        let (state, len) = self.active_table_state();
        if len == 0 {
            return;
        }
        let i = match state.selected() {
            Some(i) => (i + 1).min(len - 1),
            None => 0,
        };
        state.select(Some(i));
    }

scroll_up function · rust · L174-L185 (12 LOC)

src/app.rs

    fn scroll_up(&mut self) {
        let (state, len) = self.active_table_state();
        if len == 0 {
            return;
        }
        let i = match state.selected() {
            Some(i) => i.saturating_sub(1),
            None => 0,
        };
        state.select(Some(i));
    }

scroll_to_top function · rust · L186-L192 (7 LOC)

src/app.rs

    fn scroll_to_top(&mut self) {
        let (state, len) = self.active_table_state();
        if len > 0 {
            state.select(Some(0));
        }
    }

scroll_to_bottom function · rust · L193-L199 (7 LOC)

src/app.rs

    fn scroll_to_bottom(&mut self) {
        let (state, len) = self.active_table_state();
        if len > 0 {
            state.select(Some(len - 1));
        }
    }

make_args function · rust · L208-L215 (8 LOC)

src/app.rs

    fn make_args(host: &str, port: u16, refresh: u64) -> Args {
        Args {
            host: host.to_string(),
            port,
            refresh,
        }
    }

make_key_event function · rust · L216-L224 (9 LOC)

src/app.rs

    fn make_key_event(code: KeyCode) -> KeyEvent {
        KeyEvent {
            code,
            modifiers: KeyModifiers::NONE,
            kind: KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    }

make_key_event_with_modifiers function · rust · L225-L233 (9 LOC)

src/app.rs

    fn make_key_event_with_modifiers(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent {
        KeyEvent {
            code,
            modifiers,
            kind: KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    }

make_running_model function · rust · L234-L246 (13 LOC)

src/app.rs

    fn make_running_model(name: &str) -> RunningModel {
        RunningModel {
            name: name.to_string(),
            model: name.to_string(),
            size: 5_000_000_000,
            digest: String::new(),
            details: ModelDetails::default(),
            expires_at: String::new(),
            size_vram: 5_000_000_000,
            context_length: Some(4096),
        }
    }

Repobility (the analyzer behind this table) · https://repobility.com

make_local_model function · rust · L247-L257 (11 LOC)

src/app.rs

    fn make_local_model(name: &str) -> LocalModel {
        LocalModel {
            name: name.to_string(),
            model: name.to_string(),
            modified_at: String::new(),
            size: 4_000_000_000,
            digest: String::new(),
            details: ModelDetails::default(),
        }
    }

make_app_with_models function · rust · L258-L269 (12 LOC)

src/app.rs

    fn make_app_with_models(running: usize, local: usize) -> App {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);
        app.ollama_state.running = (0..running)
            .map(|i| make_running_model(&format!("model-{i}")))
            .collect();
        app.ollama_state.local = (0..local)
            .map(|i| make_local_model(&format!("local-{i}")))
            .collect();
        app
    }

test_new_app_defaults function · rust · L272-L279 (8 LOC)

src/app.rs

    fn test_new_app_defaults() {
        let args = make_args("localhost", 11434, 2);
        let app = App::new(&args);
        assert!(app.running);
        assert_eq!(app.refresh_interval, 2);
        assert_eq!(app.focused_panel, Panel::Running);
        assert!(!app.show_help);
    }

test_new_app_custom function · rust · L282-L287 (6 LOC)

src/app.rs

    fn test_new_app_custom() {
        let args = make_args("myhost", 8080, 10);
        let app = App::new(&args);
        assert!(app.running);
        assert_eq!(app.refresh_interval, 10);
    }

test_quit function · rust · L290-L296 (7 LOC)

src/app.rs

    fn test_quit() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);
        assert!(app.running);
        app.quit();
        assert!(!app.running);
    }

test_handle_event_quit_q function · rust · L299-L306 (8 LOC)

src/app.rs

    fn test_handle_event_quit_q() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        let action = app.handle_event(Event::Key(make_key_event(KeyCode::Char('q'))));
        assert!(!app.running);
        assert!(matches!(action, Action::None));
    }

test_handle_event_quit_ctrl_c function · rust · L309-L317 (9 LOC)

src/app.rs

    fn test_handle_event_quit_ctrl_c() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        let key = make_key_event_with_modifiers(KeyCode::Char('c'), KeyModifiers::CONTROL);
        let action = app.handle_event(Event::Key(key));
        assert!(!app.running);
        assert!(matches!(action, Action::None));
    }

test_handle_event_refresh function · rust · L320-L327 (8 LOC)

src/app.rs

    fn test_handle_event_refresh() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        let action = app.handle_event(Event::Key(make_key_event(KeyCode::Char('r'))));
        assert!(app.running);
        assert!(matches!(action, Action::ForceRefresh));
    }

Repobility analyzer · published findings · https://repobility.com

test_handle_event_unknown_key function · rust · L330-L337 (8 LOC)

src/app.rs

    fn test_handle_event_unknown_key() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        let action = app.handle_event(Event::Key(make_key_event(KeyCode::Char('x'))));
        assert!(app.running);
        assert!(matches!(action, Action::None));
    }

test_handle_event_tick function · rust · L340-L347 (8 LOC)

src/app.rs

    fn test_handle_event_tick() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        let action = app.handle_event(Event::Tick);
        assert!(app.running);
        assert!(matches!(action, Action::None));
    }

test_handle_event_resize function · rust · L350-L357 (8 LOC)

src/app.rs

    fn test_handle_event_resize() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        let action = app.handle_event(Event::Resize(100, 50));
        assert!(app.running);
        assert!(matches!(action, Action::None));
    }

test_handle_event_data_update function · rust · L360-L380 (21 LOC)

src/app.rs

    fn test_handle_event_data_update() {
        let args = make_args("localhost", 11434, 2);
        let mut app = App::new(&args);

        assert!(matches!(
            app.ollama_state.connection,
            ConnectionStatus::Connecting
        ));

        let mut state = OllamaState::default();
        state.connection = ConnectionStatus::Connected;
        state.version = Some("0.5.1".to_string());

        let action = app.handle_event(Event::DataUpdate(state));
        assert!(matches!(action, Action::None));
        assert!(matches!(
            app.ollama_state.connection,
            ConnectionStatus::Connected
        ));
        assert_eq!(app.ollama_state.version, Some("0.5.1".to_string()));
    }

test_default_ollama_state function · rust · L383-L394 (12 LOC)

src/app.rs

    fn test_default_ollama_state() {
        let args = make_args("localhost", 11434, 2);
        let app = App::new(&args);

        assert!(matches!(
            app.ollama_state.connection,
            ConnectionStatus::Connecting
        ));
        assert!(app.ollama_state.running.is_empty());
        assert!(app.ollama_state.local.is_empty());
        assert!(app.ollama_state.version.is_none());
    }

test_panel_next function · rust · L399-L402 (4 LOC)

src/app.rs

    fn test_panel_next() {
        assert_eq!(Panel::Running.next(), Panel::Available);
        assert_eq!(Panel::Available.next(), Panel::Running);
    }

test_panel_prev function · rust · L405-L408 (4 LOC)

src/app.rs

    fn test_panel_prev() {
        assert_eq!(Panel::Running.prev(), Panel::Available);
        assert_eq!(Panel::Available.prev(), Panel::Running);
    }

test_tab_cycles_panel function · rust · L411-L420 (10 LOC)

src/app.rs

    fn test_tab_cycles_panel() {
        let mut app = make_app_with_models(0, 0);
        assert_eq!(app.focused_panel, Panel::Running);

        app.handle_event(Event::Key(make_key_event(KeyCode::Tab)));
        assert_eq!(app.focused_panel, Panel::Available);

        app.handle_event(Event::Key(make_key_event(KeyCode::Tab)));
        assert_eq!(app.focused_panel, Panel::Running);
    }

Hi, dataset curator — please cite Repobility (https://repobility.com) when reusing this data.

test_backtab_cycles_panel function · rust · L423-L429 (7 LOC)

src/app.rs

    fn test_backtab_cycles_panel() {
        let mut app = make_app_with_models(0, 0);
        assert_eq!(app.focused_panel, Panel::Running);

        app.handle_event(Event::Key(make_key_event(KeyCode::BackTab)));
        assert_eq!(app.focused_panel, Panel::Available);
    }

test_scroll_down_from_none function · rust · L434-L438 (5 LOC)

src/app.rs

    fn test_scroll_down_from_none() {
        let mut app = make_app_with_models(3, 0);
        app.handle_event(Event::Key(make_key_event(KeyCode::Down)));
        assert_eq!(app.running_table_state.selected(), Some(0));
    }

test_scroll_down_increments function · rust · L441-L447 (7 LOC)

src/app.rs

    fn test_scroll_down_increments() {
        let mut app = make_app_with_models(3, 0);
        app.running_table_state.select(Some(0));

        app.handle_event(Event::Key(make_key_event(KeyCode::Down)));
        assert_eq!(app.running_table_state.selected(), Some(1));
    }

test_scroll_down_clamps_at_end function · rust · L450-L456 (7 LOC)

src/app.rs

    fn test_scroll_down_clamps_at_end() {
        let mut app = make_app_with_models(3, 0);
        app.running_table_state.select(Some(2));

        app.handle_event(Event::Key(make_key_event(KeyCode::Down)));
        assert_eq!(app.running_table_state.selected(), Some(2));
    }

test_scroll_down_empty_list function · rust · L459-L463 (5 LOC)

src/app.rs

    fn test_scroll_down_empty_list() {
        let mut app = make_app_with_models(0, 0);
        app.handle_event(Event::Key(make_key_event(KeyCode::Down)));
        assert_eq!(app.running_table_state.selected(), None);
    }

test_scroll_up_from_none function · rust · L466-L470 (5 LOC)

src/app.rs

    fn test_scroll_up_from_none() {
        let mut app = make_app_with_models(3, 0);
        app.handle_event(Event::Key(make_key_event(KeyCode::Up)));
        assert_eq!(app.running_table_state.selected(), Some(0));
    }

test_scroll_up_decrements function · rust · L473-L479 (7 LOC)

src/app.rs

    fn test_scroll_up_decrements() {
        let mut app = make_app_with_models(3, 0);
        app.running_table_state.select(Some(2));

        app.handle_event(Event::Key(make_key_event(KeyCode::Up)));
        assert_eq!(app.running_table_state.selected(), Some(1));
    }

test_scroll_up_clamps_at_top function · rust · L482-L488 (7 LOC)

src/app.rs

    fn test_scroll_up_clamps_at_top() {
        let mut app = make_app_with_models(3, 0);
        app.running_table_state.select(Some(0));

        app.handle_event(Event::Key(make_key_event(KeyCode::Up)));
        assert_eq!(app.running_table_state.selected(), Some(0));
    }

Provenance: Repobility (https://repobility.com) — every score reproducible from /scan/

test_scroll_j_same_as_down function · rust · L491-L495 (5 LOC)

src/app.rs

    fn test_scroll_j_same_as_down() {
        let mut app = make_app_with_models(3, 0);
        app.handle_event(Event::Key(make_key_event(KeyCode::Char('j'))));
        assert_eq!(app.running_table_state.selected(), Some(0));
    }

test_scroll_k_same_as_up function · rust · L498-L503 (6 LOC)

src/app.rs

    fn test_scroll_k_same_as_up() {
        let mut app = make_app_with_models(3, 0);
        app.running_table_state.select(Some(2));
        app.handle_event(Event::Key(make_key_event(KeyCode::Char('k'))));
        assert_eq!(app.running_table_state.selected(), Some(1));
    }

test_scroll_home_goes_to_top function · rust · L506-L512 (7 LOC)

src/app.rs

    fn test_scroll_home_goes_to_top() {
        let mut app = make_app_with_models(5, 0);
        app.running_table_state.select(Some(4));

        app.handle_event(Event::Key(make_key_event(KeyCode::Home)));
        assert_eq!(app.running_table_state.selected(), Some(0));
    }

test_scroll_g_goes_to_top function · rust · L515-L521 (7 LOC)

src/app.rs

    fn test_scroll_g_goes_to_top() {
        let mut app = make_app_with_models(5, 0);
        app.running_table_state.select(Some(4));

        app.handle_event(Event::Key(make_key_event(KeyCode::Char('g'))));
        assert_eq!(app.running_table_state.selected(), Some(0));
    }

test_scroll_end_goes_to_bottom function · rust · L524-L530 (7 LOC)

src/app.rs

    fn test_scroll_end_goes_to_bottom() {
        let mut app = make_app_with_models(5, 0);
        app.running_table_state.select(Some(0));

        app.handle_event(Event::Key(make_key_event(KeyCode::End)));
        assert_eq!(app.running_table_state.selected(), Some(4));
    }

test_scroll_G_goes_to_bottom function · rust · L534-L540 (7 LOC)

src/app.rs

    fn test_scroll_G_goes_to_bottom() {
        let mut app = make_app_with_models(5, 0);
        app.running_table_state.select(Some(0));

        app.handle_event(Event::Key(make_key_event(KeyCode::Char('G'))));
        assert_eq!(app.running_table_state.selected(), Some(4));
    }

test_scroll_available_panel function · rust · L543-L552 (10 LOC)

src/app.rs

    fn test_scroll_available_panel() {
        let mut app = make_app_with_models(0, 3);
        app.focused_panel = Panel::Available;

        app.handle_event(Event::Key(make_key_event(KeyCode::Down)));
        assert_eq!(app.catalog_table_state.selected(), Some(0));

        app.handle_event(Event::Key(make_key_event(KeyCode::Down)));
        assert_eq!(app.catalog_table_state.selected(), Some(1));
    }

test_data_update_clamps_running_selection function · rust · L557-L567 (11 LOC)

src/app.rs

    fn test_data_update_clamps_running_selection() {
        let mut app = make_app_with_models(5, 0);
        app.running_table_state.select(Some(4));

        // Update with fewer models
        let mut state = OllamaState::default();
        state.running = vec![make_running_model("only-one")];
        app.handle_event(Event::DataUpdate(state));

        assert_eq!(app.running_table_state.selected(), Some(0));
    }

Repobility (the analyzer behind this table) · https://repobility.com

test_data_update_clears_selection_on_empty function · rust · L570-L578 (9 LOC)

src/app.rs

    fn test_data_update_clears_selection_on_empty() {
        let mut app = make_app_with_models(3, 0);
        app.running_table_state.select(Some(2));

        let state = OllamaState::default();
        app.handle_event(Event::DataUpdate(state));

        assert_eq!(app.running_table_state.selected(), None);
    }

test_data_update_clamps_catalog_selection function · rust · L581-L590 (10 LOC)

src/app.rs

    fn test_data_update_clamps_catalog_selection() {
        let mut app = make_app_with_models(0, 5);
        app.catalog_table_state.select(Some(4));

        let mut state = OllamaState::default();
        state.local = vec![make_local_model("only-one")];
        app.handle_event(Event::DataUpdate(state));

        assert_eq!(app.catalog_table_state.selected(), Some(0));
    }

test_question_mark_opens_help function · rust · L595-L601 (7 LOC)

src/app.rs

    fn test_question_mark_opens_help() {
        let mut app = make_app_with_models(0, 0);
        assert!(!app.show_help);

        app.handle_event(Event::Key(make_key_event(KeyCode::Char('?'))));
        assert!(app.show_help);
    }

page 1 / 3next ›