Fix clide lints.

Why not, it's free.

.cargo/config.toml

@@ -1,6 +1,2 @@
 [build]
 rustflags = [ "-C", "link-arg=-fuse-ld=lld", ]
-
-[env]
-QMAKE="/opt/Qt/6.7.3/gcc_64/bin/qmake6"
-LD_LIBRARY_PATH="/opt/Qt/6.7.3/gcc_64/lib"

.github/actions/setup-qt/action.yml

@@ -0,0 +1,20 @@
+name: "Setup Qt"
+description: "Install clide dependencies"
+inputs:
+  qt-version:
+    description: "Qt version to install"
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install apt packages
+      run: |
+        sudo apt update -y
+        sudo apt install -y build-essential cmake curl libgl1-mesa-dev python3 python3-pip
+      shell: bash
+
+    - name: Install Qt
+      uses: jurplel/install-qt-action@v4
+      with:
+        version: ${{ inputs.qt-version }}

.github/workflows/build.yaml

@@ -0,0 +1,67 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - '**'
+    tags:
+      - 'v*'
+  pull_request:
+
+env:
+  QT_VERSION: 6.7.3
+
+jobs:
+  Build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Build libclide
+        run: |
+          cargo b -p libclide --release
+      - name: Build clide
+        run: |
+          cargo b --release
+
+  Test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Test libclide
+        run: |
+          cargo test -p libclide
+      - name: Test clide
+        run: |
+          cargo test
+
+  Lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Lint libclide
+        run: |
+          cargo clippy --manifest-path libclide/Cargo.toml -- -D warnings
+      - name: Lint clide
+        run: |
+          cargo clippy -- -D warnings

README.md

@@ -1,5 +1,7 @@
 # CLIDE
 
+[![Build](https://git.shaunreed.com/shaunrd0/clide/actions/workflows/build.yaml/badge.svg)](https://git.shaunreed.com/shaunrd0/clide/workflows/build.yml)
+
 CLIDE is an extendable command-line driven development environment written in Rust using the Qt UI framework that supports both full and headless Linux environments.
 The GUI is written in QML compiled through Rust using the cxx-qt crate, while the TUI was implemented using the ratatui crate.
 

build.rs

@@ -1,7 +1,7 @@
 use cxx_qt_build::{CxxQtBuilder, QmlModule};
 
 fn main() {
-    CxxQtBuilder::new_qml_module(QmlModule::new("clide.module").qml_files(&[
+    CxxQtBuilder::new_qml_module(QmlModule::new("clide.module").qml_files([
         "qml/ClideApplicationView.qml",
         "qml/ClideEditorView.qml",
         "qml/ClideExplorerView.qml",

libclide/src/fs/entry_meta.rs

@@ -35,7 +35,7 @@ impl EntryMeta {
     pub fn new<P: AsRef<Path>>(p: P) -> Result<Self> {
         let path = p.as_ref();
         let is_dir = path.is_dir();
-        let abs_path = Self::normalize(&path).to_string_lossy().to_string();
+        let abs_path = Self::normalize(path).to_string_lossy().to_string();
         let file_name = Path::new(&abs_path)
             .file_name()
             .context(format!("Failed to get file name for path: {abs_path:?}"))?

src/gui/filesystem.rs

@@ -76,7 +76,7 @@ impl qobject::FileSystem {
             return QString::default();
         }
         let meta = fs::metadata(path.to_string())
-            .expect(format!("Failed to get file metadata {path:?}").as_str());
+            .unwrap_or_else(|_| panic!("Failed to get file metadata {path:?}"));
         if !meta.is_file() {
             warn!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
             return QString::default();
@@ -114,7 +114,7 @@ impl qobject::FileSystem {
             output.push_str("</pre>\n");
             QString::from(output)
         } else {
-            return QString::default();
+            QString::default()
         }
     }
 
@@ -126,7 +126,7 @@ impl qobject::FileSystem {
     fn set_directory(self: std::pin::Pin<&mut Self>, path: &QString) -> QModelIndex {
         if !path.is_empty()
             && fs::metadata(path.to_string())
-                .expect(format!("Failed to get metadata for path {path:?}").as_str())
+                .unwrap_or_else(|_| panic!("Failed to get metadata for path {path:?}"))
                 .is_dir()
         {
             self.set_root_path(path)
@@ -147,7 +147,7 @@ impl qobject::FileSystem {
         if Path::new(&str).is_dir() {
             // Ensures directories are given a folder icon and not mistakenly resolved to a language.
             // For example, a directory named `cpp` would otherwise return a C++ icon.
-            return QString::from(FileIcon::from("dir/").to_string())
+            return QString::from(FileIcon::from("dir/").to_string());
         }
         let icon = FileIcon::from(str);
         QString::from(icon.to_string())

src/main.rs

@@ -82,7 +82,7 @@ fn main() -> Result<()> {
         RunMode::Gui => {
             trace!(target:"main()", "Starting GUI in a new process");
             Command::new(std::env::current_exe()?)
-                .args(&["--gui", app_context.path.to_str().unwrap()])
+                .args(["--gui", app_context.path.to_str().unwrap()])
                 .stdout(Stdio::null())
                 .stderr(Stdio::null())
                 .stdin(Stdio::null())

src/tui/about.rs

@@ -68,8 +68,8 @@ impl Widget for About {
             .map(|l| Line::from(Span::raw(*l)))
             .collect();
 
-        Clear::default().render(kilroy_rect, buf);
-        Clear::default().render(chunks[1], buf);
+        Clear.render(kilroy_rect, buf);
+        Clear.render(chunks[1], buf);
         Paragraph::new(about_lines)
             .block(
                 Block::default()

src/tui/app.rs

@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 use crate::tui::about::About;
-use crate::tui::app::AppComponent::{AppEditor, AppExplorer, AppLogger};
 use crate::tui::component::{Action, Component, Focus, FocusState, Visibility, VisibleState};
 use crate::tui::editor_tab::EditorTab;
 use crate::tui::explorer::Explorer;
@@ -26,7 +25,7 @@ use std::time::Duration;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum AppComponent {
-    AppEditor,
+    Editor,
     AppExplorer,
     AppLogger,
     AppMenuBar,
@@ -51,7 +50,7 @@ impl<'a> App<'a> {
             explorer: Explorer::new(&root_path)?,
             logger: Logger::new(),
             menu_bar: MenuBar::new(),
-            last_active: AppEditor,
+            last_active: AppComponent::Editor,
             about: false,
         };
         Ok(app)
@@ -87,7 +86,7 @@ impl<'a> App<'a> {
     fn draw_bottom_status(&self, area: Rect, buf: &mut Buffer) {
         // Determine help text from the most recently focused component.
         let help = match self.last_active {
-            AppEditor => match self.editor_tab.current_editor() {
+            AppComponent::Editor => match self.editor_tab.current_editor() {
                 Some(editor) => editor.component_state.help_text.clone(),
                 None => {
                     if !self.editor_tab.is_empty() {
@@ -96,9 +95,9 @@ impl<'a> App<'a> {
                     "Failed to get current Editor while getting widget help text".to_string()
                 }
             },
-            AppExplorer => self.explorer.component_state.help_text.clone(),
-            AppLogger => self.logger.component_state.help_text.clone(),
-            AppMenuBar => self.menu_bar.component_state.help_text.clone(),
+            AppComponent::AppExplorer => self.explorer.component_state.help_text.clone(),
+            AppComponent::AppLogger => self.logger.component_state.help_text.clone(),
+            AppComponent::AppMenuBar => self.menu_bar.component_state.help_text.clone(),
         };
         Paragraph::new(
             concat!(
@@ -132,15 +131,15 @@ impl<'a> App<'a> {
         info!(target:Self::ID, "Changing widget focus to {:?}", focus);
         self.clear_focus();
         match focus {
-            AppEditor => match self.editor_tab.current_editor_mut() {
+            AppComponent::Editor => match self.editor_tab.current_editor_mut() {
                 None => {
                     error!(target:Self::ID, "Failed to get current Editor while changing focus")
                 }
                 Some(editor) => editor.component_state.set_focus(Focus::Active),
             },
-            AppExplorer => self.explorer.component_state.set_focus(Focus::Active),
-            AppLogger => self.logger.component_state.set_focus(Focus::Active),
-            AppMenuBar => self.menu_bar.component_state.set_focus(Focus::Active),
+            AppComponent::AppExplorer => self.explorer.component_state.set_focus(Focus::Active),
+            AppComponent::AppLogger => self.logger.component_state.set_focus(Focus::Active),
+            AppComponent::AppMenuBar => self.menu_bar.component_state.set_focus(Focus::Active),
         }
         self.last_active = focus;
     }
@@ -255,21 +254,21 @@ impl<'a> Component for App<'a> {
         }
         // Handle events for all components.
         let action = match self.last_active {
-            AppEditor => self.editor_tab.handle_event(event.clone())?,
-            AppExplorer => self.explorer.handle_event(event.clone())?,
-            AppLogger => self.logger.handle_event(event.clone())?,
+            AppComponent::Editor => self.editor_tab.handle_event(event.clone())?,
+            AppComponent::AppExplorer => self.explorer.handle_event(event.clone())?,
+            AppComponent::AppLogger => self.logger.handle_event(event.clone())?,
             AppMenuBar => self.menu_bar.handle_event(event.clone())?,
         };
 
         // Components should always handle mouse events for click interaction.
-        if let Some(mouse) = event.as_mouse_event() {
-            if mouse.kind == MouseEventKind::Down(MouseButton::Left) {
-                if let Some(editor) = self.editor_tab.current_editor_mut() {
-                    editor.handle_mouse_events(mouse)?;
-                }
-                self.explorer.handle_mouse_events(mouse)?;
-                self.logger.handle_mouse_events(mouse)?;
+        if let Some(mouse) = event.as_mouse_event()
+            && mouse.kind == MouseEventKind::Down(MouseButton::Left)
+        {
+            if let Some(editor) = self.editor_tab.current_editor_mut() {
+                editor.handle_mouse_events(mouse)?;
             }
+            self.explorer.handle_mouse_events(mouse)?;
+            self.logger.handle_mouse_events(mouse)?;
         }
 
         // Handle actions returned from widgets that may need context on other widgets or app state.
@@ -349,7 +348,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppExplorer);
+                self.change_focus(AppComponent::AppExplorer);
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -358,7 +357,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppEditor);
+                self.change_focus(AppComponent::Editor);
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -367,7 +366,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppLogger);
+                self.change_focus(AppComponent::AppLogger);
                 Ok(Action::Handled)
             }
             KeyEvent {

src/tui/editor.rs

@@ -115,9 +115,8 @@ impl Component for Editor {
     fn handle_event(&mut self, event: Event) -> Result<Action> {
         if let Some(key_event) = event.as_key_event() {
             // Handle events here that should not be passed on to the vim emulation handler.
-            match self.handle_key_events(key_event)? {
-                Action::Handled => return Ok(Action::Handled),
-                _ => {}
+            if let Action::Handled = self.handle_key_events(key_event)? {
+                return Ok(Action::Handled)
             }
         }
         self.event_handler.on_event(event, &mut self.state);

src/tui/explorer.rs

@@ -4,7 +4,8 @@
 
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
 use anyhow::{Context, Result, bail};
-use log::{trace};
+use libclide::fs::entry_meta::EntryMeta;
+use log::trace;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, MouseEvent, MouseEventKind};
 use ratatui::layout::{Alignment, Position, Rect};
@@ -14,7 +15,6 @@ use ratatui::widgets::{Block, Borders, StatefulWidget, Widget};
 use std::fs;
 use std::path::{Path, PathBuf};
 use tui_tree_widget::{Tree, TreeItem, TreeState};
-use libclide::fs::entry_meta::EntryMeta;
 
 #[derive(Debug)]
 pub struct Explorer<'a> {
@@ -30,8 +30,8 @@ impl<'a> Explorer<'a> {
     pub fn new(path: &PathBuf) -> Result<Self> {
         trace!(target:Self::ID, "Building {}", Self::ID);
         let explorer = Explorer {
-            root_path: EntryMeta::new(&path)?,
-            tree_items: Self::build_tree_from_path(path.to_owned())?,
+            root_path: EntryMeta::new(path)?,
+            tree_items: Self::build_tree_from_path(path)?,
             tree_state: TreeState::default(),
             component_state: ComponentState::default().with_help_text(concat!(
                 "(↑/k)/(↓/j): Select item | ←/h: Close folder | →/l: Open folder |",
@@ -96,7 +96,7 @@ impl<'a> Explorer<'a> {
 
 impl<'a> Widget for &mut Explorer<'a> {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        if let Ok(tree) = Tree::new(&self.tree_items.children()) {
+        if let Ok(tree) = Tree::new(self.tree_items.children()) {
             StatefulWidget::render(
                 tree.block(
                     Block::default()
@@ -130,23 +130,21 @@ impl<'a> Component for Explorer<'a> {
                 _ => {}
             }
         }
-        if let Some(mouse_event) = event.as_mouse_event() {
-            match self.handle_mouse_events(mouse_event)? {
-                Action::Handled => return Ok(Action::Handled),
-                _ => {}
-            }
+        if let Some(mouse_event) = event.as_mouse_event()
+            && let Action::Handled = self.handle_mouse_events(mouse_event)?
+        {
+            return Ok(Action::Handled);
         }
         Ok(Action::Pass)
     }
 
     fn handle_key_events(&mut self, key: KeyEvent) -> Result<Action> {
-        if key.code == KeyCode::Enter {
-            if let Ok(selected) = self.selected() {
-                if Path::new(&selected).is_file() {
-                    return Ok(Action::OpenTab);
-                }
-            }
-            // Otherwise fall through and handle Enter in the next match case.
+        if key.code == KeyCode::Enter
+            && let Ok(selected) = self.selected()
+            && Path::new(&selected).is_file()
+        {
+            // Open a tab if the selected item is a file.
+            return Ok(Action::OpenTab);
         }
 
         let changed = match key.code {

src/tui/menu_bar.rs

@@ -131,7 +131,7 @@ impl MenuBar {
         opened: MenuBarItem,
     ) {
         let popup_area = Self::rect_under_option(title_bar_anchor, area, 27, 10);
-        Clear::default().render(popup_area, buf);
+        Clear.render(popup_area, buf);
         let options = opened.options().iter().map(|i| ListItem::new(i.id()));
         StatefulWidget::render(
             List::new(options)
@@ -150,15 +150,14 @@ impl MenuBar {
     }
 
     fn rect_under_option(anchor: Rect, area: Rect, width: u16, height: u16) -> Rect {
-        let rect = Rect {
+        Rect {
             x: anchor.x,
             y: anchor.y + anchor.height,
             width: width.min(area.width),
             height,
-        };
+        }
         // TODO: X offset for item option? It's fine as-is, but it might look nicer.
         // trace!(target:Self::ID, "Building Rect under MenuBar popup {}", rect);
-        rect
     }
 }