rename to jocalsend

Cargo.lock

@@ -1150,7 +1150,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "joecalsend"
+name = "jocalsend"
 version = "0.1.0"
 dependencies = [
  "axum",

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "joecalsend"
+name = "jocalsend"
 version = "0.1.0"
 edition = "2024"
 

src/app/mod.rs

@@ -2,7 +2,7 @@ use std::{collections::BTreeMap, net::SocketAddr, time::Duration};
 
 use crossterm::event::{Event, EventStream, KeyCode, KeyEvent, KeyEventKind};
 use futures::{FutureExt, StreamExt};
-use joecalsend::{JoecalService, ReceiveDialog, ReceiveRequest, TransferEvent, error::Result};
+use jocalsend::{JocalService, ReceiveDialog, ReceiveRequest, TransferEvent, error::Result};
 use julid::Julid;
 use log::{LevelFilter, debug, error, warn};
 use ratatui::{
@@ -23,7 +23,7 @@ pub struct Peer {
 }
 
 pub struct App {
-    pub service: JoecalService,
+    pub service: JocalService,
     pub events: EventStream,
     // addr -> (alias, fingerprint)
     pub peers: Vec<Peer>,
@@ -56,7 +56,7 @@ pub enum SendingScreen {
 }
 
 impl App {
-    pub fn new(service: JoecalService, event_listener: UnboundedReceiver<TransferEvent>) -> Self {
+    pub fn new(service: JocalService, event_listener: UnboundedReceiver<TransferEvent>) -> Self {
         App {
             service,
             event_listener,

src/app/widgets.rs

@@ -1,6 +1,6 @@
 use std::sync::LazyLock;
 
-use joecalsend::ReceiveRequest;
+use jocalsend::ReceiveRequest;
 use log::LevelFilter;
 use ratatui::{
     buffer::Buffer,
@@ -217,7 +217,7 @@ impl Widget for &mut App {
 }
 
 fn outer_frame(screen: &CurrentScreen, menu: &Line, area: Rect, buf: &mut Buffer) {
-    let title = Line::from(" Joecalsend ".bold());
+    let title = Line::from(" Jocalsend ".bold());
     let block = Block::bordered()
         .title(title.centered())
         .title_bottom(menu.clone().centered())
@@ -364,13 +364,13 @@ impl Widget for NetworkInfoWidget {
     {
         let udp = "UDP socket";
         let udp = udp.to_line().left_aligned();
-        let uaddr = format!("{:?}", joecalsend::LISTENING_SOCKET_ADDR);
+        let uaddr = format!("{:?}", jocalsend::LISTENING_SOCKET_ADDR);
         let udp = Row::new(vec![udp, uaddr.to_line().right_aligned()]).yellow();
 
         let mip = format!(
             "{:?}:{:?}",
-            joecalsend::MULTICAST_IP,
-            joecalsend::DEFAULT_PORT
+            jocalsend::MULTICAST_IP,
+            jocalsend::DEFAULT_PORT
         );
         let multicast = "Multicast address";
         let multicast = Row::new(vec![
@@ -379,7 +379,7 @@ impl Widget for NetworkInfoWidget {
         ])
         .yellow();
 
-        let haddr = format!("{:?}", joecalsend::LISTENING_SOCKET_ADDR);
+        let haddr = format!("{:?}", jocalsend::LISTENING_SOCKET_ADDR);
         let http = "HTTP address";
         let http = Row::new(vec![
             http.to_line().left_aligned(),

src/discovery.rs

@@ -11,9 +11,9 @@ use axum::{
 use log::{debug, error, trace, warn};
 use tokio::net::UdpSocket;
 
-use crate::{Config, JoecalService, RunningState, models::Device};
+use crate::{Config, JocalService, RunningState, models::Device};
 
-impl JoecalService {
+impl JocalService {
     pub async fn announce(&self, socket: Option<SocketAddr>) -> crate::error::Result<()> {
         trace!("announcing");
         announce_http(&self.device, socket, self.client.clone()).await?;
@@ -97,7 +97,7 @@ impl JoecalService {
 
 /// Axum request handler for receiving other devices' registration requests.
 pub async fn register_device(
-    State(service): State<JoecalService>,
+    State(service): State<JocalService>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
     Json(device): Json<Device>,
 ) -> Json<Device> {

src/http_server.rs

@@ -9,12 +9,12 @@ use tokio::{net::TcpListener, sync::mpsc};
 use tower_http::limit::RequestBodyLimitLayer;
 
 use crate::{
-    JoecalService,
+    JocalService,
     discovery::register_device,
     transfer::{prepare_upload, receive_upload},
 };
 
-impl JoecalService {
+impl JocalService {
     pub async fn start_http_server(&self, stop_rx: mpsc::Receiver<()>) -> crate::error::Result<()> {
         let app = self.create_router();
         // TODO: make addr config

src/lib.rs

@@ -60,7 +60,7 @@ pub struct ReceiveRequest {
 
 /// Contains the main network and backend state for an application session.
 #[derive(Clone)]
-pub struct JoecalService {
+pub struct JocalService {
     pub device: Device,
     pub peers: Arc<Mutex<BTreeMap<String, (SocketAddr, Device)>>>,
     pub sessions: Arc<Mutex<BTreeMap<String, Session>>>, // Session ID to Session
@@ -74,7 +74,7 @@ pub struct JoecalService {
     transfer_event_tx: UnboundedSender<TransferEvent>,
 }
 
-impl JoecalService {
+impl JocalService {
     pub async fn new(
         device: Device,
         config: Config,
@@ -190,7 +190,7 @@ pub struct Config {
 impl Default for Config {
     fn default() -> Self {
         let home = std::env::home_dir().unwrap_or("/tmp".into());
-        let dd = home.join("joecalsend-downloads");
+        let dd = home.join("jocalsend-downloads");
         Self {
             multicast_addr: SocketAddrV4::new(MULTICAST_IP, DEFAULT_PORT),
             port: DEFAULT_PORT,

src/main.rs

@@ -1,4 +1,4 @@
-use joecalsend::{Config, JoecalService, Listeners, error, models::Device};
+use jocalsend::{Config, JocalService, Listeners, error, models::Device};
 use log::{error, info};
 use ratatui::DefaultTerminal;
 use tokio::{sync::mpsc::unbounded_channel, task::JoinSet};
@@ -12,7 +12,7 @@ fn main() -> error::Result<()> {
 
     if std::env::var("RUST_LOG").is_err() {
         unsafe {
-            std::env::set_var("RUST_LOG", "joecalsend");
+            std::env::set_var("RUST_LOG", "jocalsend");
         }
     }
     init_logger(LevelFilter::Info).map_err(|e| std::io::Error::other(format!("{e}")))?;
@@ -35,9 +35,9 @@ async fn start_and_run(
 ) -> error::Result<()> {
     let (event_tx, event_listener) = unbounded_channel();
 
-    let service = JoecalService::new(device, config.clone(), event_tx)
+    let service = JocalService::new(device, config.clone(), event_tx)
         .await
-        .expect("Could not create JoecalService");
+        .expect("Could not create JocalService");
 
     let mut app = App::new(service, event_listener);
 

src/models.rs

@@ -120,7 +120,7 @@ pub enum Protocol {
 impl Default for Device {
     fn default() -> Self {
         Self {
-            alias: "Joecalsend".to_string(),
+            alias: "Jocalsend".to_string(),
             version: "2.1".to_string(),
             device_model: None,
             device_type: Some(DeviceType::Headless),

src/transfer.rs

@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc::unbounded_channel;
 
 use crate::{
-    JoecalService, ReceiveDialog, ReceiveRequest, TransferEvent,
+    JocalService, ReceiveDialog, ReceiveRequest, TransferEvent,
     error::{LocalSendError, Result},
     models::{Device, FileMetadata},
 };
@@ -52,7 +52,7 @@ pub struct PrepareUploadRequest {
     pub files: BTreeMap<String, FileMetadata>,
 }
 
-impl JoecalService {
+impl JocalService {
     pub async fn prepare_upload(
         &self,
         peer: &str,
@@ -231,7 +231,7 @@ impl JoecalService {
 }
 
 pub async fn prepare_upload(
-    State(service): State<JoecalService>,
+    State(service): State<JocalService>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
     Json(req): Json<PrepareUploadRequest>,
 ) -> impl IntoResponse {
@@ -302,7 +302,7 @@ pub async fn prepare_upload(
 
 pub async fn receive_upload(
     Query(params): Query<UploadParams>,
-    State(service): State<JoecalService>,
+    State(service): State<JocalService>,
     body: Bytes,
 ) -> impl IntoResponse {
     // Extract query parameters
@@ -379,7 +379,7 @@ pub struct UploadParams {
 
 pub async fn register_cancel(
     Query(params): Query<CancelParams>,
-    State(service): State<JoecalService>,
+    State(service): State<JocalService>,
 ) -> impl IntoResponse {
     let mut sessions_lock = service.sessions.lock().await;
     let session = match sessions_lock.get_mut(&params.session_id) {