text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>mod first_line;
mod one_line_ui;
mod second_line;
mod tip;
use ansi_term::{
ANSIString,
Colour::{Fixed, RGB},
Style,
};
use std::collections::BTreeMap;
use std:<|fim_suffix|> let active_tab = self.tabs.iter().find(|t| t.active);
let first_line = first_line(&self.mode_info, active_tab... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{ANSIString, ANSIStrings};
use ansi_term::{
Color::{Fixed, RGB},
Style,
};
use std::collections::HashMap;
use zellij_tile::prelude::actions::Action;
use zellij_tile::prelude::*;
use zellij_tile_utils::palette_match;
use crate::first_line::{to_char, KeyAction, KeyMode, KeyShortcut};... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{
unstyled_len, ANSIString, ANSIStrings,
Color::{Fixed, RGB},
Style,
};
use zellij_tile::prelude::actions::Action;
use zellij_tile::prelude::*;
use zellij_tile_utils::palette_match;
use crate::{
action_key, action_key_group, style_key_with_modifier,
tip::{data::TIPS, Ti... | fim | zellij-org/zellij | rust |
<|fim_suffix|>_cache)?;
Ok(LocalCache { path, metadata })
},
Err(e) => Err(LocalCacheError::IoPath(e, path)),
}
}
pub fn flush(&mut self) -> Result<(), LocalCacheError> {
match serde_json::to_string(&self.metadata) {
Ok(json_cache) => {
... | fim | zellij-org/zellij | rust |
<|fim_suffix|>bug where the plugin load function is called twice, and sot he cache is hit twice
<|fim_prefix|>pub const DEFAULT_CACHE_FILE_PATH: &str = "/tmp/status-bar-tips.cache";
p<|fim_middle|>ub const MAX_CACHE_HITS: usize = 20; // this should be 10, but right now there's a <|endoftext|> | fim | zellij-org/zellij | rust |
use ansi_term::{
unstyled_len, ANSIString, ANSIStrings,
Color::{Fixed, RGB},
Style,
};
use crate::LinePart;
use crate::{action_key, style_key_with_modifier};
use zellij_tile::prelude::{actions::Action, *};
use zellij_tile_utils::palette_match;
macro_rules! strings {
($ANSIStrings:expr) => {{
l... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{
unstyled_len, ANSIString, ANSIStrings,
Color::{Fixed, RGB},
Style,
};
use crate::{action_key, style_key_with_modifier, LinePart};
use zellij_tile::prelude::{actions::Action, *};
use zellij_tile_utils::palette_match;
macro_rules! strings {
($ANSIStrings:expr) => {{
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{unstyled_len, ANSIString, ANSIStrings, Style};
use crate::{action_key, style_key_with_modifier, LinePart};
use zellij_tile::prelude::{actions::Action, *};
macro_rules! strings {
($ANSIStrings:expr) => {{
let strings: &[ANSIString] = $ANSIStrings;
let ansi_strings = A... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use std::collections::HashMap;
use lazy_static::lazy_static;
use crate::tip::TipBody;
mod compact_layout;
mod edit_scrollbuffer;
mod floating_panes_mouse;
mod move_focus_hjkl_tab_switch;
mod move_tabs;
mod quicknav;
mod send_mouse_click_to_termi<|fim_suffix|> short: edit_scrollbuffer::edit_scrollb... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{unstyled_len, ANSIString, ANSIStrings, Style};
use crate::{action_key_group, style_key_with_modifier, LinePart};
use zellij_tile::prelude::{actions::Action, *};
macro_rules! strings {
($ANSIStrings:expr) => {{
let strings: &[ANSIString] = $ANSIStrings;
let ansi_strin... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{
unstyled_len, ANSIString, ANSIStrings,
Color::{Fixed, RGB},
Style,
};
use zellij_tile::prelude::*;
use zellij_tile_utils::palette_match;
use crate::LinePart;
macro_rules! strings {
($ANSIStrings:expr) => {{
let strings: &[ANSIString] = $ANSIStrings;
let... | fim | zellij-org/zellij | rust |
<|fim_suffix|> direction: None,
pane_name: None,
start_suppressed: false,
}],
);
let new_pane = if new_pane_keys.is_empty() {
vec![Style::new().bold().paint("UNBOUND")]
} else {
style_key_with_modifier(&new_pane_keys, &help.style.colors, None)
};
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use ansi_term::{
unstyled_len, ANSIString, ANSIStrings,
Color::{Fixed, RGB},
Style,
};
use crate::LinePart;
use zellij_tile::prelude::*;
use zellij_tile_utils::palette_match;
macro_rules! strings {
($ANSIStrings:expr) => {{
let strings: &[ANSIString] = $ANSIStrings;
let ... | fim | zellij-org/zellij | rust |
use ansi_term::{unstyled_len, ANSIString, ANSIStrings, Style};
use crate::{action_key, style_key_with_modifier, LinePart};
use zellij_tile::prelude::{actions::Action, *};
macro_rules! strings {
($ANSIStrings:expr) => {{
let strings: &[ANSIString] = $ANSIStrings;
let ansi_strings = ANSIStrings(str... | fim | zellij-org/zellij | rust |
<|fim_suffix|> switch pane/tabs or scroll."),
])
}
<|fim_prefix|>use ansi_term::{
unstyled_len, ANSIString, ANSIStrings,
Color::{Fixed, RGB},
Style,
};
use crate::LinePart;
use zellij_tile::p<|fim_middle|>relude::*;
use zellij_tile_utils::palette_match;
macro_rules! strings {
($ANSIStrings:expr) =... | fim | zellij-org/zellij | rust |
<|fim_suffix|>tyle::new().paint(" to find issues"),
])
}
pub fn zellij_setup_check_short(help: &ModeInfo) -> LinePart {
// Run "zellij setup --check" to find issues
let orange_color = palette_match!(help.style.colors.text_unselected.emphasis_0);
strings!(&[
Style::new().paint(" Run "),
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>pub mod cache;
pu<|fim_suffix|>tils;
use crate::LinePart;
use zellij_tile::prelude::*;
pub type TipFn = fn(&ModeInfo) -> LinePart;
pub struct TipBody {
pub short: TipFn,
pub medium: TipFn,
pub full: TipFn,
}
<|fim_middle|>b mod consts;
pub mod data;
pub mod u<|endoftext|> | fim | zellij-org/zellij | rust |
<|fim_suffix|>_set();
let diff = TIPS
.keys()
.cloned()
.filter(|k| !cached_set.contains(&k.to_string()))
.collect::<Vec<&str>>();
if !diff.is_empty() {
get_name_and_caching!(local_cache, diff);
} else {
local_cache.clear()... | fim | zellij-org/zellij | rust |
<|fim_suffix|> FsEntry::Dir(p) => p.clone(),
FsEntry::File(p, _) => p.clone(),
}
}
pub fn is_hidden_file(&self) -> bool {
self.name().starts_with('.')
}
pub fn is_folder(&self) -> bool {
matches!(self, FsEntry::Dir(_))
}
}
<|fim_prefix|>use crate::platform::... | fim | zellij-org/zellij | rust |
<|fim_suffix|> BareKey::Char('e') if key.has_modifiers(&[KeyModifier::Ctrl]) => {
should_render = true;
self.toggle_hidden_files();
refresh_directory(&self.file_list_view.path);
},
_ => (),
},
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use std::path::{Path, PathBuf};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Platform {
Unix,
Windows,
}
impl Default for Platform {
fn default() -> Self {
Platform::Unix
}
}
impl Platform {
/// Detect the host platform from the initial_cwd string.
/// Checks fo... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::file_list_view::FsEntry;
use crate::platform::Platform;
use crate::shared::{calculate_list_bounds, render_list_tip};
use fuzzy_matcher::skim::SkimMatcherV2;
use fuzzy_matcher::FuzzyMatcher;
use pretty_bytes::converter::convert as pretty_bytes;
use unicode_width::UnicodeWidthStr;
use zellij_tile... | fim | zellij-org/zellij | rust |
<|fim_suffix|> <ENTER>", prompt, current_path))
.color_range(2, 0..prompt_len)
.color_range(0, prompt_len..path_end)
.color_range(3, path_end + 1..path_end + 9);
print_text(current_path);
}
println!();
println!();
}
fn truncate_path(path: PathBuf, mut char_count_... | fim | zellij-org/zellij | rust |
<|fim_suffix|>(self.virtual_root_selected) {
let path = entry.get_full_pathbuf();
self.is_in_virtual_root = false;
self.file_list_view.path = path.clone();
self.file_list_view.path_is_dir = true;
self.file_list_view.files.clear();
... | fim | zellij-org/zellij | rust |
use ansi_term::ANSIStrings;
use unicode_width::UnicodeWidthStr;
use crate::{LinePart, ARROW_SEPARATOR};
use zellij_tile::prelude::actions::Action;
use zellij_tile::prelude::*;
use zellij_tile_utils::style;
fn get_current_title_len(current_title: &[LinePart]) -> usize {
current_title.iter().map(|p| p.len).sum()
}
... | fim | zellij-org/zellij | rust |
<|fim_suffix|>) => match me {
Mouse::LeftClick(_, col) => {
let tab_to_focus = get_tab_to_focus(&self.tab_line, self.active_tab_idx, col);
if let Some(idx) = tab_to_focus {
switch_tab_to(idx.try_into().unwrap());
}
... | fim | zellij-org/zellij | rust |
<|fim_suffix|> None
}
pub(crate) fn get_clicked_line_part(
tab_line: &[LinePart],
mouse_click_col: usize,
) -> Option<&LinePart> {
let mut len = 0;
for tab_line_part in tab_line {
if mouse_click_col >= len && mouse_click_col < len + tab_line_part.len {
return Some(tab_line_part);... | fim | zellij-org/zellij | rust |
<|fim_suffix|>mpile("assets/zellij.rc", embed_resource::NONE);
}
<|fim_prefix|>fn main() {
// The clap-d<|fim_middle|>erived `augment_subcommands` for `CliAction` (~70 variants)
// produces a >1 MB stack frame in debug mode, overflowing the Windows
// default 1 MB main-thread stack. Increase it to 8 MB to ... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use dialoguer::Confirm;
use std::net::IpAddr;
use std::{fs::File, io::prelude::*, path::PathBuf, process, time::Duration};
#[cfg(feature = "web_server_capability")]
use isahc::{config::RedirectPolicy, prelude::*, HttpClient, Request};
use zellij_client::{
old_config_converter::{
config_yaml_... | fim | zellij-org/zellij | rust |
<|fim_prefix|>mod commands;
#[cfg(test)]
mod tests;
use clap::Parser;
use zellij_utils::{
cli::{CliAction, CliArgs, Command, Sessions},
consts::{create_config_and_cache_folders, VERSION},
data::UnblockCondition,
envs,
input::config::Config,
logging::*,
setup::Setup,
shared::web_server_b... | fim | zellij-org/zellij | rust |
use std::net::{IpAddr, Ipv4Addr};
use clap::{CommandFactory, Parser};
use zellij_utils::cli::{CliArgs, Command};
#[test]
fn verify_cli() {
CliArgs::command().debug_assert();
}
#[test]
fn web_cli_status_alone_works() {
let args = CliArgs::try_parse_from(["zellij", "web", "--status"]);
assert!(args.is_ok()... | fim | zellij-org/zellij | rust |
pub mod cases;
mod remote_runner;
mod steps;
<|endoftext|> | fim | zellij-org/zellij | rust |
<|fim_suffix|>_EXECUTABLE_LOCATION, command
)
.as_bytes(),
)
.unwrap();
channel.flush().unwrap();
}
pub fn path_to_fixture_folder(&self) -> String {
ZELLIJ_FIXTURE_PATH.to_string()
}
pub fn load_fixture(&mut self, name: &str) {
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use super::cases::{
MOVE_FOCUS_LEFT_IN_NORMAL_MODE, MOVE_TAB_LEFT, MOVE_TAB_RIGHT, NEW_TAB_IN_TAB_MODE,
SECOND_TAB_CONTENT, TAB_MODE,
};
use super::remote_runner::{RemoteTerminal, Step};
pub fn new_tab() -> Step {
Step {
name: "Open new tab",
instruction: |mut remote_terminal:... | fim | zellij-org/zellij | rust |
<|fim_prefix|>pub mod cli;
pub mod<|fim_suffix|>e2e;
<|fim_middle|> <|endoftext|> | fim | zellij-org/zellij | rust |
<|fim_suffix|> println!();
let msg = format!(">> Building '{crate_name}'");
crate::status(&msg);
println!("{}", msg);
let mut base_cmd = cmd!(sh, "{cargo} build");
if flags.release {
base_cmd = base_cmd.arg("--release");
} els... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Tasks related to zellij CI
use crate::{
build,
flags::{self, BuildRelease, CiCmd, Cross, E2e},
metadata,
};
use anyhow::Context;
use st<|fim_suffix|>get: &OsString, no_web: bool) -> anyhow::Result<()> {
let err_context = || format!("failed to cross-compile for {target:?}");
crate:... | fim | zellij-org/zellij | rust |
<|fim_suffix|>uldn't find 'clippy' executable. Please install it with `rustup component add clippy`",
)
}
<|fim_prefix|>//! Handle running `cargo clippy` on the sources.
use crate::{build, flags, WorkspaceMember};
use anyhow::Context;
use std::path::{Path, PathBuf};
use xshell::{cmd, Shell};
pub fn clippy(sh: &She... | fim | zellij-org/zellij | rust |
//! CLI flags for `cargo xtask`
use std::ffi::OsString;
use std::path::PathBuf;
xflags::xflags! {
src "./src/flags.rs"
/// Custom build commands for zellij
cmd xtask {
/// Deprecation warning. Compatibility to transition from `cargo make`.
cmd deprecated {
repeated _args: OsStr... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Handle running `cargo fmt` on the sources.
use crate::{flags, WorkspaceMember};
use anyhow::Context;
use std::path::{Path, PathBuf};
use xshell::{cmd, Shell};
pub fn format(sh: &Shell, flags: flags::Format) -> anyhow::Result<()> {
let _pd = sh.push_dir(crate::project_root());
let cargo = che... | fim | zellij-org/zellij | rust |
//! See <https://github.com/matklad/cargo-xtask/>.
//!
//! This binary defines various auxiliary build commands, which are not expressible with just
//! `cargo`. Notably, it provides tests via `cargo test -p xtask` for code generation and `cargo
//! xtask install` for installation of rust-analyzer server and client.
//... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Helper functions for querying cargo metadata
use anyhow::Context;
use serde_json::Value;
use xshell::{cmd, Shell};
/// Get cargo metadata for the workspace
pub fn get_cargo_metadata(sh: &Shell) -> anyhow::Result<Value> {
let cargo = crate::cargo().context("Failed to find cargo executable")?;
... | fim | zellij-org/zellij | rust |
<|fim_suffix|> project_dir
.join("zellij-utils")
.join("assets")
.join("config")
.join("default.kdl"),
project_dir.join("example").join("default.kdl"),
)
.context(err_context)?;
// Commit changes
cmd!(sh, "git c... | fim | zellij-org/zellij | rust |
<|fim_suffix|>text(|| format!("Failed to run tests for '{}'", crate_name))?;
}
Ok(())
}
pub fn host_target_triple(sh: &Shell) -> anyhow::Result<String> {
let rustc_ver = cmd!(sh, "rustc -vV")
.read()
.context("Failed to determine host triple")?;
let maybe_triple = rustc_ver
.lin... | fim | zellij-org/zellij | rust |
<|fim_prefix|>!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardAddon=e():t.ClipboardAddon=e()}<|fim_suffix|>pqrstuvwxyz0123456789+/="),a=(t={},u.forEach((function(e,r){return t[e]=r})),t),c=/^... | fim | zellij-org/zellij | javascript |
/*
Taken from @xterm/addon-fit v0.10.0
The following license refers to this file and the functions
within it only
Copyright (c) 2019, The xterm.js authors (https://github.com/xtermjs/xterm.js)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation ... | fim | zellij-org/zellij | javascript |
<|fim_suffix|>omputeLink(e,this._regex,this._terminal,this._handler);t(this._addCallbacks(n))}_addCallbacks(e){return e.map((e=>(e.leave=this._options.leave,e.hover=(t,n)=>{if(this._options.hover){const{range:o}=e;this._options.hover(t,n,o)}},e)))}};class o{static computeLink(e,t,r,i){const s=new RegExp(t.source,(t.fla... | fim | zellij-org/zellij | javascript |
<|fim_suffix|>tionCookie = document.body.dataset.authenticated === "true";
if (!hasAuthenticationCookie) {
const tokenResult = await waitForSecurityToken();
token = tokenResult.token;
remember = tokenResult.remember;
}
let webClientId;
while (!webClientId) {
webClientI... | fim | zellij-org/zellij | javascript |
<|fim_suffix|>|| isPageUnloading) {
return;
}
isDisconnected = true;
await showErrorModal("Disconnected", "You have been disconnected by the host.");
isDisconnected = false;
}
/**
* Handle reconnection attempts with exponential backoff
* @returns {Promise<void>}
*/
export async function hand... | fim | zellij-org/zellij | javascript |
<|fim_suffix|> ev.data
) {
state.sendFn(ev.data);
ev.target.value = "";
state.lastKeyWasProcess = false;
}
},
true
);
};
attach();
}
<|fim_prefix|>export function installImeBy... | fim | zellij-org/zellij | javascript |
<|fim_suffix|>tAddon, sendAnsiKey);
document.title = sessionName;
const websockets = initWebSockets(webClientId, sessionName, term, fitAddon, sendAnsiKey);
sendAnsiKey = websockets.sendAnsiKey;
setupInputHandlers(term, fitAddon, sendAnsiKey);
});
<|fim_prefix|>import { initConnectionHandlers } from '... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>import { installImeBypass } from <|fim_suffix|>tion);
installSoftKeyboardCapture(term, sendFunction);
suppressSoftKeyboardOnTouch(term);
installCustomKeyHandler(term, sendFunction);
const terminalElement = document.getElementById("terminal");
installMouseHandlers(term, terminalElement... | fim | zellij-org/zellij | javascript |
<|fim_suffix|> (ev.key == "-" && ev.altKey)
) {
ev.preventDefault();
encode_kitty_key(ev, sendFunction);
return false;
}
}
return true;
});
}
function hasModifiersToHandle(ev) {
const MODIFIER_KEYS = ["Shift", "Contr... | fim | zellij-org/zellij | javascript |
/**
* Keyboard handling functions
*/
/**
* Encode a keyboard event into kitty protocol ANSI escape sequence
* @param {KeyboardEvent} ev - The keyboard event to encode
* @param {function} send_ansi_key - Function to send the ANSI key sequence
*/
export function encode_kitty_key(ev, send_ansi_key) {
let shift_... | fim | zellij-org/zellij | javascript |
<|fim_suffix|>lor = '#150262';
popup.innerText = "Shift-Click: " + text;
const topElement = event.target.parentNode;
topElement.appendChild(popup);
const popupHeight = popup.offsetHeight;
_linkPopup = popup;
}
function activateLink(event, uri) {
const newWind... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>function createModalStyles() {
if (document.querySelector('#modal-styles')) return;
const zellijGreen = '#A3BD8D';
const zellijGreenDark = '#7A9B6A';
const zellijBlue = '#7E9FBE';
const zellijBlueDark = '#5A7EA0';
const zellijYellow = '#EACB8B';
const errorRed = '#BE616B';
const errorRe... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>export function installMouseHandlers(term, terminalElement, sendFunction) {
let prev_col = 0;
let prev_row = 0;
// xterm.js doesn't emit mousemove (xtermjs/xterm.js#1062); synthesize SGR motion reports.
terminalElement.addEventListener("mousemove", function (event) {
if (event.but... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>import { clampFontSize } from "./terminal.js";
// xterm.js's WebGL renderer clears the framebuffer when it reassigns
// canvas.width/height on a font-size change, and during a touch gesture the
// repaint is rAF-throttled, so the cleared canvas can flash blank before the
// repaint lands. This overlay pi... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>export function isCoarsePointerDevice() {
if (window.matchMedia && window.matchMedia("(pointer: coarse)").matches) {
return true;
}
if (typeof navigator !== "undefined" && navigator.maxTouchPoints > 0) {
return true;
}
if ("ontouchstart" in window) {
return true... | fim | zellij-org/zellij | javascript |
import { build_link_handler } from "./links.js";
// drawImage on a composited WebGL canvas returns blank pixels unless
// preserveDrawingBuffer is set (needed by the pinch overlay snapshot); this must
// run before xterm.js's WebglAddon creates its context.
function ensurePreserveDrawingBuffer() {
if (window.__zjP... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>import { clampFontSize } from "./terminal.js";
import { toggleSoftKeyboard } from "./soft-keyboard.js";
const SGR_COORD_BASE = 1;
export function installTouchGestures({ term, terminalElement, sendFunction, pinch }) {
let last_touch_y = null;
let last_touch_x = null;
let pending_scroll = 0;
... | fim | zellij-org/zellij | javascript |
<|fim_prefix|>/**
* Utility functions for the terminal web client
*/
/**
* Check if the current page is served over HTTPS
* @returns {boolean} true if protocol is https:, false otherwise
*/
export function is_https() {
return document.location.protocol === "https:";
}
export function isMac() {
if (naviga... | fim | zellij-org/zellij | javascript |
import { handleReconnection, handleDisconnected, markConnectionEstablished } from "./connection.js";
import { getBaseUrl, getWebSocketBaseUrl } from "./utils.js";
import { setSoftKeyboard } from "./input.js";
import { applyFontSize } from "./terminal.js";
const NATURAL_MIN_TOTAL_ROWS = 25;
const MOBILE_LEGIBLE_FLOOR_P... | fim | zellij-org/zellij | javascript |
<|fim_suffix|> }
let _ = stdout.flush();
},
SubscribeFormat::Json => {
let json = serde_json::json!({
"event": "pane_update",
"pane_id": pane_id.to_string(),
"v... | fim | zellij-org/zellij | rust |
<|fim_prefix|>#![allow(clippy::mutex_atomic)]
use std::sync::{Arc, Condvar, Mutex};
#[derive(Clone)]
pub(crate) struct CommandIsExecuting {
input_thread: Arc<(Mutex<bool>, Condvar)>,
}
impl CommandIsExecuting {
pub fn new() -> Self {
CommandIsExecuting {
input_thread: Arc::new((Mutex::new(... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Main input logic.
use crate::{
os_input_output::ClientOsApi, stdin_ansi_parser::AnsiStdinInstruction, ClientId,
ClientInstruction, CommandIsExecuting, InputInstruction,
};
use zellij_utils::{
channels::{Receiver, SenderWithContext, OPENCALLS},
data::{InputMode, KeyWithModifier},
er... | fim | zellij-org/zellij | rust |
<|fim_suffix|>
assert_eq!(
parse_for_test(key.as_bytes()),
Some(KeyWithModifier::new(BareKey::Right).with_ctrl_modifier()),
"Can parse a bare 'Right' keypress with ctrl"
);
let key = "\u{1b}[1;5A";
assert_eq!(
parse_for_test(key.as_bytes()),
Some(KeyWithModifier::... | fim | zellij-org/zellij | rust |
<|fim_suffix|>os_input.get_stdout_writer();
stdout.write_all(clear_screen.as_bytes()).unwrap();
stdout.flush().unwrap();
}
let _ = send_input_instructions.send(InputInstruction::Exit);
reconnect_to_session
}
pub fn start_server_detached(
mut os_input: Box<dyn ClientOsApi>,
cli_arg... | fim | zellij-org/zellij | rust |
<|fim_suffix|> explicitly_set_layout_file.display(),
explicitly_set_layout_file_kdl_equivalent.display()
)
);
}
if !layout_files_to_convert.is_empty() {
print_conversion_layouts_message(layout_files_to_convert.clone());
}
if !theme_files_to_convert.is_... | fim | zellij-org/zellij | rust |
mod convert_old_yaml_files;
mod old_config;
mod old_layout;
pub use convert_old_yaml_files::convert_old_yaml_files;
pub use old_config::config_yaml_to_config_kdl;
pub use old_layout::layout_yaml_to_layout_kdl;
<|endoftext|> | fim | zellij-org/zellij | rust |
<|fim_suffix|>Error> {
match self {
Self::Down => write!(f, "Down"),
Self::Up => write!(f, "Up"),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
enum OldSearchOption {
CaseSensitivity,
WholeWord,
Wrap,
}
impl std::fmt::Display for OldSearch... | fim | zellij-org/zellij | rust |
<|fim_suffix|> bool,
#[serde(default)]
pub tabs: Vec<OldTabLayout>,
}
#[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq)]
pub struct OldSessionFromYaml {
pub name: Option<String>,
#[serde(default = "default_as_some_true")]
pub attach: Option<bool>,
}
fn default_as_some_true() -> Op... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::old_config_converter::config_yaml_to_config_kdl;
use insta::assert_snapshot;
use std::path::PathBuf;
use std::{fs::File, io::prelude::*};
#[test]
fn properly_convert_default_config() -> Result<(), String> {
let fixture = PathBuf::from(format!(
"{}/src/old_config_converter/unit/fixt... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::old_config_converter::layout_yaml_to_layout_kdl;
use insta::assert_snapshot;
use std::path::PathBuf;
use std::{fs::File, io::prelude::*};
#[test]
fn properly_convert_default_layout() -> Result<(), String> {
let fixture = PathBuf::from(format!(
"{}/src/old_config_converter/unit/fixt... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use anyhow::Result;
use async_trait::async_trait;
use zellij_utils::pane_size::Size;
#[cfg(not(windows))]
use crate::os_input_output_unix::{
disable_mouse_support, enable_mouse_support, setup_ipc, AsyncSignalListener,
BlockingSignalIterator,
};
#[cfg(windows)]
use crate::os_input_output_windows::... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::os_input_output::SignalEvent;
use async_trait::async_trait;
use signal_hook::consts::signal::*;
use signal_hook::iterator::Signals;
use tokio::signal::unix::{signal, SignalKind};
use anyhow::{Context, Result};
use std::io;
use std::io::Write;
use std::path::Path;
use zellij_utils::ipc::{IpcRe... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::os_input_output::SignalEvent;
use crate::stdin_handler_windows::restore_vt_input;
use anyhow::{Context, Result};
use async_trait::async_trait;
use std::io;
use std::io::Write;
use std::path::Path;
use zellij_utils::ipc::{IpcReceiverWithContext, IpcSenderWithContext};
/// Windows async signal... | fim | zellij-org/zellij | rust |
<|fim_suffix|>ormat!("{}{}", server_base_url, SESSION_ENDPOINT);
let mut session_response = http_client
.send_with_cookies(
Request::post(session_url)
.header("Content-Type", "application/json")
.header("User-Agent", "http-terminal-client/1.0")
.h... | fim | zellij-org/zellij | rust |
use std::time::Duration;
// API endpoints
pub const LOGIN_ENDPOINT: &str = "/command/login";
pub const SESSION_ENDPOINT: &str = "/session";
pub const WS_TERMINAL_ENDPOINT: &str = "/ws/terminal";
pub const WS_CONTROL_ENDPOINT: &str = "/ws/control";
// Connection settings
pub const CONNECTION_TIMEOUT_SECS: u64 = 30;
p... | fim | zellij-org/zellij | rust |
<|fim_suffix|>name.to_lowercase().as_str())
{
cookies.insert(name.trim().to_string(), value.trim().to_string());
}
}
}
}
}
pub fn get_cookie_header(&self) -> Option<String> {
if let Ok(cookies) = self.co... | fim | zellij-org/zellij | rust |
<|fim_suffix|>return Err(e);
},
}
}
Ok(None)
}
fn authenticate_with_retry(
runtime: Handle,
remote_session_url: &str,
initial_token: Option<String>,
remember: bool,
ca_cert: Option<&std::path::Path>,
insecure: bool,
) -> Result<WebSocketConnections, RemoteClientError... | fim | zellij-org/zellij | rust |
<|fim_suffix|>ach_tests;
<|fim_prefix|>mod rem<|fim_middle|>ote_att<|endoftext|> | fim | zellij-org/zellij | rust |
use super::super::*;
use crate::RemoteClientError;
use serial_test::serial;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use zellij_utils::remote_session_tokens;
// Mock server infrastructure
#[cfg(feature = "web_server_capability")]
mod mock_server {
use super::*;
use a... | fim | zellij-org/zellij | rust |
<|fim_suffix|> "{}://{}{WS_TERMINAL_ENDPOINT}/{}?web_client_id={}",
ws_protocol,
base_host,
urlencoding::encode(session_name),
urlencoding::encode(web_client_id)
)
};
let control_url = format!("{}://{}{WS_CONTROL_ENDPOINT}", ws_protocol, base_host... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Continuous, parser for host-terminal replies arriving on
//! stdin.
//!
//! This parser routes stdin bytes through a private `termwiz::InputParser`,
//! classifies OSC / CSI-report events into `HostReply` variants, and lets
//! all other bytes (keyboard input) pass through as a residue byte sequence
/... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Unit tests for the continuous host-reply parser.
use super::{schedule_forward_timeout, HostReply, StdinAnsiParser};
use std::sync::{Arc, Mutex};
use std::time::Duration;
/// Helper: collect replies and residue from a single `feed` call.
fn feed_once(parser: &mut StdinAnsiParser, bytes: &[u8]) -> (Ve... | fim | zellij-org/zellij | rust |
<|fim_suffix|> if can_query_terminal {
let query_string = build_startup_query_string();
let _ = os_input
.get_stdout_writer()
.write(query_string.as_bytes())
.unwrap();
}
}
#[cfg(windows)]
if !use_vt_reader {
crate... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use std::sync::OnceLock;
use crossterm::event::{self, Event, KeyEventKind};
use windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE;
use windows_sys::Win32::System::Console::{
GetConsoleMode, GetStdHandle, SetConsoleMode, ENABLE_EXTENDED_FLAGS, ENABLE_MOUSE_INPUT,
ENABLE_VIRTUAL_TERMINAL_INPUT, ... | fim | zellij-org/zellij | rust |
<|fim_suffix|>ts;
<|fim_prefix|>#[cfg(test)]
#[cfg(f<|fim_middle|>eature = "web_server_capability")]
mod terminal_loop_tes<|endoftext|> | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::os_input_output::{AsyncSignals, AsyncStdin, ClientOsApi, SignalEvent};
use crate::remote_attach::websockets::MaybeTls;
use crate::remote_attach::WebSocketConnections;
use crate::run_remote_client_terminal_loop;
use crate::web_client::control_message::{
WebClientToWebServerControlMessage, We... | fim | zellij-org/zellij | rust |
<|fim_suffix|>th secure and non-secure versions
// in case the user was on http before and is now on https
// or vice versa
let clear_cookies = [
Cookie::build(("session_token", ""))
.http_only(true)
.secure(false)
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::os_input_output::ClientOsApi;
use crate::web_client::control_message::WebServerToWebClientControlMessage;
use crate::web_client::types::{ClientChannels, ClientConnectionBus, ConnectionTable};
use axum::extract::ws::{CloseFrame, Message};
use std::sync::{atomic::AtomicBool, Arc};
use tokio::sync... | fim | zellij-org/zellij | rust |
<|fim_suffix|>
.web_client
.cursor_inactive_style
.as_ref()
.map(|s| s.to_string());
let font_size = config.web_client.font_size;
SetConfigPayload {
font,
theme,
cursor_blink,
mac_option_is_meta,
... | fim | zellij-org/zellij | rust |
<|fim_prefix|>//! Builds the IPC messages that seed Screen's host-terminal-query cache
//! with web-client data on attach (and on subsequent config reloads).
//!
//! The native client populates `Screen.terminal_emulator_colors`,
//! `Screen.pixel_dimensions` and `Screen.terminal_emulator_color_codes`
//! by forwarding ... | fim | zellij-org/zellij | rust |
<|fim_suffix|>hes('/');
match ASSETS_DIR.get_file(path) {
None => (
[(header::CONTENT_TYPE, "text/html")],
"Not Found".as_bytes(),
),
Some(file) => {
let ext = file.path().extension().and_then(|ext| ext.to_str());
let mime_type = get_mime_type... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use axum_server::Handle;
use interprocess::local_socket::traits::tokio::Listener;
use std::net::IpAddr;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use zellij_utils::consts::{ipc_bind_async, WEBSERVER_SOCKET_PATH};
use zellij_utils::prost::Message;
use zellij_utils::web_server_commands::{InstructionForW... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::input_handler::from_termwiz;
use crate::keyboard_parser::{KittyKeyboardParser, KittyParseOutcome};
use crate::os_input_output::ClientOsApi;
use crate::web_client::types::BRACKETED_PASTE_END;
use crate::web_client::types::BRACKETED_PASTE_START;
use std::sync::{
atomic::{AtomicBool, Ordering}... | fim | zellij-org/zellij | rust |
<|fim_prefix|>pub mod control_message;
pub(crate) mod authentication;
mod connection_manager;
mod host_query_seed;
mod http_handlers;
mod ipc_listener;
mod message_handlers;
mod server_listener;
mod session_management;
mod types;
mod utils;
mod websocket_handlers;
use std::{
net::{IpAddr, Ipv4Addr},
path::Pat... | fim | zellij-org/zellij | rust |
<|fim_suffix|>entMsg::LogError{lines}) => {
client_connection_bus.send_control(
WebServerToWebClientControlMessage::LogError { lines },
);
},
Some(ServerToClientMsg... | fim | zellij-org/zellij | rust |
<|fim_prefix|>use crate::os_input_output::ClientOsApi;
use crate::spawn_server;
use std::{fs, path::PathBuf};
use zellij_utils::{
consts::session_layout_cache_file_name,
data::{ConnectToSession, LayoutInfo, LayoutMetadata, WebSharing},
envs,
input::{cli_assets::CliAssets, config::Config, options::Optio... | fim | zellij-org/zellij | rust |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.