@ -1,296 +1,464 @@
// Implementation reference: https://github.com/neovim/neovim/blob/f2906a4669a2eef6d7bf86a29648793d63c98949/runtime/autoload/provider/clipboard.vim#L68-L152
// Implementation reference: https://github.com/neovim/neovim/blob/f2906a4669a2eef6d7bf86a29648793d63c98949/runtime/autoload/provider/clipboard.vim#L68-L152
use anyhow::Result ; use serde::{ Deserialize , Serialize } ;
use std ::borrow ::Cow ; use std ::borrow ::Cow ;
use thiserror ::Error ;
#[ derive(Clone, Copy , Debug )] #[ derive(Clone, Copy )]
pub enum ClipboardType { pub enum ClipboardType {
Clipboard , Clipboard ,
Selection , Selection ,
} }
pub trait ClipboardProvider : std ::fmt ::Debug { #[ derive(Debug, Error) ]
fn name ( & self ) -> Cow < str > ; pub enum ClipboardError {
fn get_contents ( & self , clipboard_type : ClipboardType ) -> Result < String > ; #[ error(transparent) ]
fn set_contents ( & mut self , contents : String , clipboard_type : ClipboardType ) -> Result < ( ) > ; IoError ( #[ from ] std ::io ::Error ) ,
#[ error( " could not convert terminal output to UTF-8: {0} " ) ]
FromUtf8Error ( #[ from ] std ::string ::FromUtf8Error ) ,
#[ cfg(windows) ]
#[ error( " Windows API error: {0} " ) ]
WinAPI ( #[ from ] clipboard_win ::ErrorCode ) ,
#[ error( " clipboard provider command failed " ) ]
CommandFailed ,
#[ error( " failed to write to clipboard provider's stdin " ) ]
StdinWriteFailed ,
#[ error( " clipboard provider did not return any contents " ) ]
MissingStdout ,
#[ error( " This clipboard provider does not support reading " ) ]
ReadingNotSupported ,
} }
#[ cfg(not(windows)) ] type Result < T > = std ::result ::Result < T , ClipboardError > ;
macro_rules! command_provider {
( paste = > $get_prg :literal $( , $get_arg :literal ) * ; copy = > $set_prg :literal $( , $set_arg :literal ) * ; ) = > { { #[ cfg(not(target_arch = " wasm32 " )) ]
log ::debug ! ( pub use external ::ClipboardProvider ;
"Using {} to interact with the system clipboard" , #[ cfg(target_arch = " wasm32 " ) ]
if $set_prg ! = $get_prg { format! ( "{}+{}" , $set_prg , $get_prg ) } else { $set_prg . to_string ( ) } pub use noop ::ClipboardProvider ;
) ;
Box ::new ( provider ::command ::Provider { // Clipboard not supported for wasm
get_cmd : provider ::command ::Config { #[ cfg(target_arch = " wasm32 " ) ]
prg : $get_prg , mod noop {
args : & [ $( $get_arg ) , * ] , use super ::* ;
} ,
set_cmd : provider ::command ::Config { #[ derive(Debug, Clone) ]
prg : $set_prg , pub enum ClipboardProvider { }
args : & [ $( $set_arg ) , * ] ,
} , impl ClipboardProvider {
get_primary_cmd : None , pub fn detect ( ) -> Self {
set_primary_cmd : None , Self
} ) }
} } ;
pub fn name ( & self ) -> Cow < str > {
( paste = > $get_prg :literal $( , $get_arg :literal ) * ; "none" . into ( )
copy = > $set_prg :literal $( , $set_arg :literal ) * ; }
primary_paste = > $pr_get_prg :literal $( , $pr_get_arg :literal ) * ;
primary_copy = > $pr_set_prg :literal $( , $pr_set_arg :literal ) * ; pub fn get_contents ( & self , _clipboard_type : ClipboardType ) -> Result < String > {
) = > { { Err ( ClipboardError ::ReadingNotSupported )
log ::debug ! (
"Using {} to interact with the system and selection (primary) clipboard" ,
if $set_prg ! = $get_prg { format! ( "{}+{}" , $set_prg , $get_prg ) } else { $set_prg . to_string ( ) }
) ;
Box ::new ( provider ::command ::Provider {
get_cmd : provider ::command ::Config {
prg : $get_prg ,
args : & [ $( $get_arg ) , * ] ,
} ,
set_cmd : provider ::command ::Config {
prg : $set_prg ,
args : & [ $( $set_arg ) , * ] ,
} ,
get_primary_cmd : Some ( provider ::command ::Config {
prg : $pr_get_prg ,
args : & [ $( $pr_get_arg ) , * ] ,
} ) ,
set_primary_cmd : Some ( provider ::command ::Config {
prg : $pr_set_prg ,
args : & [ $( $pr_set_arg ) , * ] ,
} ) ,
} )
} } ;
} }
pub fn set_contents ( & self , _content : & str , _clipboard_type : ClipboardType ) -> Result < ( ) > {
Ok ( ( ) )
}
}
}
#[ cfg(not(target_arch = " wasm32 " )) ]
mod external {
use super ::* ;
#[ derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq) ]
pub struct Command {
command : Cow < ' static , str > ,
#[ serde(default) ]
args : Cow < ' static , [ Cow < ' static , str > ] > ,
}
#[ derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq) ]
#[ serde(rename_all = " kebab-case " ) ]
pub struct CommandProvider {
yank : Command ,
paste : Command ,
yank_primary : Option < Command > ,
paste_primary : Option < Command > ,
}
#[ derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq) ]
#[ serde(rename_all = " kebab-case " ) ]
#[ allow(clippy::large_enum_variant) ]
pub enum ClipboardProvider {
Pasteboard ,
Wayland ,
XClip ,
XSel ,
Win32Yank ,
Tmux ,
#[ cfg(windows) ] #[ cfg(windows) ]
pub fn get_clipboard_provider ( ) -> Box < dyn ClipboardProvider > { Windows ,
Box ::< provider ::WindowsProvider > ::default ( ) Termux ,
#[ cfg(feature = " term " ) ]
Termcode ,
Custom ( CommandProvider ) ,
None ,
}
impl Default for ClipboardProvider {
#[ cfg(windows) ]
fn default ( ) -> Self {
use helix_stdx ::env ::binary_exists ;
if binary_exists ( "win32yank.exe" ) {
Self ::Win32Yank
} else {
Self ::Windows
}
} }
#[ cfg(target_os = " macos " ) ] #[ cfg(target_os = " macos " ) ]
pub fn get_clipboard_provider ( ) -> Box < dyn ClipboardProvider > { fn default ( ) -> Self {
use helix_stdx ::env ::{ binary_exists , env_var_is_set } ; use helix_stdx ::env ::{ binary_exists , env_var_is_set } ;
if env_var_is_set ( "TMUX" ) & & binary_exists ( "tmux" ) { if env_var_is_set ( "TMUX" ) & & binary_exists ( "tmux" ) {
command_provider ! { Self ::Tmux
paste = > "tmux" , "save-buffer" , "-" ;
copy = > "tmux" , "load-buffer" , "-w" , "-" ;
}
} else if binary_exists ( "pbcopy" ) & & binary_exists ( "pbpaste" ) { } else if binary_exists ( "pbcopy" ) & & binary_exists ( "pbpaste" ) {
command_provider ! { Self ::Pasteboard
paste = > "pbpaste" ; } else if cfg! ( feature = "term" ) {
copy = > "pbcopy" ; Self ::Termcode
}
} else { } else {
Box ::new ( provider ::FallbackProvider ::new ( ) ) Self ::None
} }
} }
#[ cfg(target_arch = " wasm32 " ) ] #[ cfg(not(any(windows, target_os = " macos " ))) ]
pub fn get_clipboard_provider ( ) -> Box < dyn ClipboardProvider > { fn default ( ) -> Self {
// TODO:
Box ::new ( provider ::FallbackProvider ::new ( ) )
}
#[ cfg(not(any(windows, target_arch = " wasm32 " , target_os = " macos " ))) ]
pub fn get_clipboard_provider ( ) -> Box < dyn ClipboardProvider > {
use helix_stdx ::env ::{ binary_exists , env_var_is_set } ; use helix_stdx ::env ::{ binary_exists , env_var_is_set } ;
use provider ::command ::is_exit_success ;
// TODO: support for user-defined provider, probably when we have plugin support by setting a
// variable?
if env_var_is_set ( "WAYLAND_DISPLAY" ) & & binary_exists ( "wl-copy" ) & & binary_exists ( "wl-paste" ) { fn is_exit_success ( program : & str , args : & [ & str ] ) -> bool {
command_provider ! { std ::process ::Command ::new ( program )
paste = > "wl-paste" , "--no-newline" ; . args ( args )
copy = > "wl-copy" , "--type" , "text/plain" ; . output ( )
primary_paste = > "wl-paste" , "-p" , "--no-newline" ; . ok ( )
primary_copy = > "wl-copy" , "-p" , "--type" , "text/plain" ; . and_then ( | out | out . status . success ( ) . then_some ( ( ) ) )
. is_some ( )
} }
if env_var_is_set ( "WAYLAND_DISPLAY" )
& & binary_exists ( "wl-copy" )
& & binary_exists ( "wl-paste" )
{
Self ::Wayland
} else if env_var_is_set ( "DISPLAY" ) & & binary_exists ( "xclip" ) { } else if env_var_is_set ( "DISPLAY" ) & & binary_exists ( "xclip" ) {
command_provider ! { Self ::XClip
paste = > "xclip" , "-o" , "-selection" , "clipboard" ;
copy = > "xclip" , "-i" , "-selection" , "clipboard" ;
primary_paste = > "xclip" , "-o" ;
primary_copy = > "xclip" , "-i" ;
}
} else if env_var_is_set ( "DISPLAY" ) } else if env_var_is_set ( "DISPLAY" )
& & binary_exists ( "xsel" ) & & binary_exists ( "xsel" )
// FIXME: check performance of is_exit_success
& & is_exit_success ( "xsel" , & [ "-o" , "-b" ] ) & & is_exit_success ( "xsel" , & [ "-o" , "-b" ] )
{ {
// FIXME: check performance of is_exit_success
Self ::XSel
command_provider ! { } else if binary_exists ( "termux-clipboard-set" ) & & binary_exists ( "termux-clipboard-get" )
paste = > "xsel" , "-o" , "-b" ; {
copy = > "xsel" , "-i" , "-b" ; Self ::Termux
primary_paste = > "xsel" , "-o" ; } else if env_var_is_set ( "TMUX" ) & & binary_exists ( "tmux" ) {
primary_copy = > "xsel" , "-i" ; Self ::Tmux
}
} else if binary_exists ( "win32yank.exe" ) { } else if binary_exists ( "win32yank.exe" ) {
command_provider ! { Self ::Win32Yank
paste = > "win32yank.exe" , "-o" , "--lf" ; } else if cfg! ( feature = "term" ) {
copy = > "win32yank.exe" , "-i" , "--crlf" ; Self ::Termcode
} else {
Self ::None
} }
} else if binary_exists ( "termux-clipboard-set" ) & & binary_exists ( "termux-clipboard-get" ) {
command_provider ! {
paste = > "termux-clipboard-get" ;
copy = > "termux-clipboard-set" ;
} }
} else if env_var_is_set ( "TMUX" ) & & binary_exists ( "tmux" ) {
command_provider ! {
paste = > "tmux" , "save-buffer" , "-" ;
copy = > "tmux" , "load-buffer" , "-w" , "-" ;
} }
impl ClipboardProvider {
pub fn name ( & self ) -> Cow < ' _ , str > {
fn builtin_name < ' a > (
name : & ' static str ,
provider : & ' static CommandProvider ,
) -> Cow < ' a , str > {
if provider . yank . command ! = provider . paste . command {
Cow ::Owned ( format! (
"{} ({}+{})" ,
name , provider . yank . command , provider . paste . command
) )
} else { } else {
Box ::new ( provider ::FallbackProvider ::new ( ) ) Cow ::Owned ( format! ( "{} ({})" , name , provider . yank . command ) )
} }
} }
#[ cfg(not(target_os = " windows " )) ] match self {
pub mod provider { // These names should match the config option names from Serde
use super ::{ ClipboardProvider , ClipboardType } ; Self ::Pasteboard = > builtin_name ( "pasteboard" , & PASTEBOARD ) ,
use anyhow ::Result ; Self ::Wayland = > builtin_name ( "wayland" , & WL_CLIPBOARD ) ,
use std ::borrow ::Cow ; Self ::XClip = > builtin_name ( "x-clip" , & WL_CLIPBOARD ) ,
Self ::XSel = > builtin_name ( "x-sel" , & WL_CLIPBOARD ) ,
Self ::Win32Yank = > builtin_name ( "win-32-yank" , & WL_CLIPBOARD ) ,
Self ::Tmux = > builtin_name ( "tmux" , & TMUX ) ,
Self ::Termux = > builtin_name ( "termux" , & TERMUX ) ,
#[ cfg(windows) ]
Self ::Windows = > "windows" . into ( ) ,
#[ cfg(feature = " term " ) ] #[ cfg(feature = " term " ) ]
mod osc52 { Self ::Termcode = > "termcode" . into ( ) ,
use { super ::ClipboardType , crate ::base64 } ; Self ::Custom ( command_provider ) = > Cow ::Owned ( format! (
"custom ({}+{})" ,
command_provider . yank . command , command_provider . paste . command
) ) ,
Self ::None = > "none" . into ( ) ,
}
}
#[ derive(Debug) ] pub fn get_contents ( & self , clipboard_type : & ClipboardType ) -> Result < String > {
pub struct SetClipboardCommand { fn yank_from_builtin (
encoded_content : String , provider : CommandProvider ,
clipboard_type : ClipboardType , clipboard_type : & ClipboardType ,
) -> Result < String > {
match clipboard_type {
ClipboardType ::Clipboard = > execute_command ( & provider . yank , None , true ) ?
. ok_or ( ClipboardError ::MissingStdout ) ,
ClipboardType ::Selection = > {
if let Some ( cmd ) = provider . yank_primary . as_ref ( ) {
return execute_command ( cmd , None , true ) ?
. ok_or ( ClipboardError ::MissingStdout ) ;
} }
impl SetClipboardCommand { Ok ( String ::new ( ) )
pub fn new ( content : & str , clipboard_type : ClipboardType ) -> Self {
Self {
encoded_content : base64 ::encode ( content . as_bytes ( ) ) ,
clipboard_type ,
} }
} }
} }
impl crossterm ::Command for SetClipboardCommand { match self {
fn write_ansi ( & self , f : & mut impl std ::fmt ::Write ) -> std ::fmt ::Result { Self ::Pasteboard = > yank_from_builtin ( PASTEBOARD , clipboard_type ) ,
let kind = match & self . clipboard_type { Self ::Wayland = > yank_from_builtin ( WL_CLIPBOARD , clipboard_type ) ,
ClipboardType ::Clipboard = > "c" , Self ::XClip = > yank_from_builtin ( XCLIP , clipboard_type ) ,
ClipboardType ::Selection = > "p" , Self ::XSel = > yank_from_builtin ( XSEL , clipboard_type ) ,
} ; Self ::Win32Yank = > yank_from_builtin ( WIN32 , clipboard_type ) ,
// Send an OSC 52 set command: https://terminalguide.namepad.de/seq/osc-52/
Self ::Tmux = > yank_from_builtin ( TMUX , clipboard_type ) ,
write! ( f , "\x1b]52;{};{}\x1b\\" , kind , & self . encoded_content ) Self ::Termux = > yank_from_builtin ( TERMUX , clipboard_type ) ,
#[ cfg(target_os = " windows " ) ]
Self ::Windows = > match clipboard_type {
ClipboardType ::Clipboard = > {
let contents =
clipboard_win ::get_clipboard ( clipboard_win ::formats ::Unicode ) ? ;
Ok ( contents )
} }
ClipboardType ::Selection = > Ok ( String ::new ( ) ) ,
} ,
#[ cfg(feature = " term " ) ]
Self ::Termcode = > Err ( ClipboardError ::ReadingNotSupported ) ,
Self ::Custom ( command_provider ) = > {
execute_command ( & command_provider . yank , None , true ) ?
. ok_or ( ClipboardError ::MissingStdout )
}
Self ::None = > Err ( ClipboardError ::ReadingNotSupported ) ,
} }
} }
#[ derive(Debug) ] pub fn set_contents ( & self , content : & str , clipboard_type : ClipboardType ) -> Result < ( ) > {
pub struct FallbackProvider { fn paste_to_builtin (
buf : String , provider : CommandProvider ,
primary_buf : String , content : & str ,
clipboard_type : ClipboardType ,
) -> Result < ( ) > {
let cmd = match clipboard_type {
ClipboardType ::Clipboard = > & provider . paste ,
ClipboardType ::Selection = > {
if let Some ( cmd ) = provider . paste_primary . as_ref ( ) {
cmd
} else {
return Ok ( ( ) ) ;
}
}
} ;
execute_command ( cmd , Some ( content ) , false ) . map ( | _ | ( ) )
} }
impl FallbackProvider { match self {
pub fn new ( ) -> Self { Self ::Pasteboard = > paste_to_builtin ( PASTEBOARD , content , clipboard_type ) ,
Self ::Wayland = > paste_to_builtin ( WL_CLIPBOARD , content , clipboard_type ) ,
Self ::XClip = > paste_to_builtin ( XCLIP , content , clipboard_type ) ,
Self ::XSel = > paste_to_builtin ( XSEL , content , clipboard_type ) ,
Self ::Win32Yank = > paste_to_builtin ( WIN32 , content , clipboard_type ) ,
Self ::Tmux = > paste_to_builtin ( TMUX , content , clipboard_type ) ,
Self ::Termux = > paste_to_builtin ( TERMUX , content , clipboard_type ) ,
#[ cfg(target_os = " windows " ) ]
Self ::Windows = > match clipboard_type {
ClipboardType ::Clipboard = > {
clipboard_win ::set_clipboard ( clipboard_win ::formats ::Unicode , content ) ? ;
Ok ( ( ) )
}
ClipboardType ::Selection = > Ok ( ( ) ) ,
} ,
#[ cfg(feature = " term " ) ] #[ cfg(feature = " term " ) ]
log ::debug ! ( Self ::Termcode = > {
"No native clipboard provider found. Yanking by OSC 52 and pasting will be internal to Helix" crossterm ::queue ! (
) ; std ::io ::stdout ( ) ,
#[ cfg(not(feature = " term " )) ] osc52 ::SetClipboardCommand ::new ( content , clipboard_type )
log ::warn ! ( ) ? ;
"No native clipboard provider found! Yanking and pasting will be internal to Helix" Ok ( ( ) )
) ;
Self {
buf : String ::new ( ) ,
primary_buf : String ::new ( ) ,
} }
Self ::Custom ( command_provider ) = > match clipboard_type {
ClipboardType ::Clipboard = > {
execute_command ( & command_provider . paste , Some ( content ) , false ) . map ( | _ | ( ) )
} }
ClipboardType ::Selection = > {
if let Some ( cmd ) = & command_provider . paste_primary {
execute_command ( cmd , Some ( content ) , false ) . map ( | _ | ( ) )
} else {
Ok ( ( ) )
} }
impl Default for FallbackProvider {
fn default ( ) -> Self {
Self ::new ( )
} }
} ,
Self ::None = > Ok ( ( ) ) ,
} }
impl ClipboardProvider for FallbackProvider {
#[ cfg(feature = " term " ) ]
fn name ( & self ) -> Cow < str > {
Cow ::Borrowed ( "termcode" )
} }
#[ cfg(not(feature = " term " )) ]
fn name ( & self ) -> Cow < str > {
Cow ::Borrowed ( "none" )
} }
fn get_contents ( & self , clipboard_type : ClipboardType ) -> Result < String > { macro_rules! command_provider {
// This is the same noop if term is enabled or not.
( $name :ident ,
// We don't use the get side of OSC 52 as it isn't often enabled, it's a security hole,
yank = > $yank_cmd :literal $( , $yank_arg :literal ) * ;
// and it would require this to be async to listen for the response
paste = > $paste_cmd :literal $( , $paste_arg :literal ) * ; ) = > {
let value = match clipboard_type { const $name : CommandProvider = CommandProvider {
ClipboardType ::Clipboard = > self . buf . clone ( ) , yank : Command {
ClipboardType ::Selection = > self . primary_buf . clone ( ) , command : Cow ::Borrowed ( $yank_cmd ) ,
args : Cow ::Borrowed ( & [ $( Cow ::Borrowed ( $yank_arg ) ) , * ] )
} ,
paste : Command {
command : Cow ::Borrowed ( $paste_cmd ) ,
args : Cow ::Borrowed ( & [ $( Cow ::Borrowed ( $paste_arg ) ) , * ] )
} ,
yank_primary : None ,
paste_primary : None ,
} ;
} ;
( $name :ident ,
yank = > $yank_cmd :literal $( , $yank_arg :literal ) * ;
paste = > $paste_cmd :literal $( , $paste_arg :literal ) * ;
yank_primary = > $yank_primary_cmd :literal $( , $yank_primary_arg :literal ) * ;
paste_primary = > $paste_primary_cmd :literal $( , $paste_primary_arg :literal ) * ; ) = > {
const $name : CommandProvider = CommandProvider {
yank : Command {
command : Cow ::Borrowed ( $yank_cmd ) ,
args : Cow ::Borrowed ( & [ $( Cow ::Borrowed ( $yank_arg ) ) , * ] )
} ,
paste : Command {
command : Cow ::Borrowed ( $paste_cmd ) ,
args : Cow ::Borrowed ( & [ $( Cow ::Borrowed ( $paste_arg ) ) , * ] )
} ,
yank_primary : Some ( Command {
command : Cow ::Borrowed ( $yank_primary_cmd ) ,
args : Cow ::Borrowed ( & [ $( Cow ::Borrowed ( $yank_primary_arg ) ) , * ] )
} ) ,
paste_primary : Some ( Command {
command : Cow ::Borrowed ( $paste_primary_cmd ) ,
args : Cow ::Borrowed ( & [ $( Cow ::Borrowed ( $paste_primary_arg ) ) , * ] )
} ) ,
} ;
} ; } ;
Ok ( value )
} }
fn set_contents ( & mut self , content : String , clipboard_type : ClipboardType ) -> Result < ( ) > { command_provider ! {
#[ cfg(feature = " term " ) ] TMUX ,
crossterm ::execute ! ( yank = > "tmux" , "load-buffer" , "-w" , "-" ;
std ::io ::stdout ( ) , paste = > "tmux" , "save-buffer" , "-" ;
osc52 ::SetClipboardCommand ::new ( & content , clipboard_type )
) ? ;
// Set our internal variables to use in get_content regardless of using OSC 52
match clipboard_type {
ClipboardType ::Clipboard = > self . buf = content ,
ClipboardType ::Selection = > self . primary_buf = content ,
} }
Ok ( ( ) ) command_provider ! {
PASTEBOARD ,
yank = > "pbcopy" ;
paste = > "pbpaste" ;
} }
command_provider ! {
WL_CLIPBOARD ,
yank = > "wl-copy" , "--type" , "text/plain" ;
paste = > "wl-paste" , "--no-newline" ;
yank_primary = > "wl-copy" , "-p" , "--type" , "text/plain" ;
paste_primary = > "wl-paste" , "-p" , "--no-newline" ;
}
command_provider ! {
XCLIP ,
yank = > "xclip" , "-i" , "-selection" , "clipboard" ;
paste = > "xclip" , "-o" , "-selection" , "clipboard" ;
yank_primary = > "xclip" , "-i" ;
paste_primary = > "xclip" , "-o" ;
}
command_provider ! {
XSEL ,
yank = > "xsel" , "-i" , "-b" ;
paste = > "xsel" , "-o" , "-b" ;
yank_primary = > "xsel" , "-i" ;
paste_primary = > "xsel" , "-o" ;
}
command_provider ! {
WIN32 ,
yank = > "win32yank.exe" , "-i" , "--crlf" ;
paste = > "win32yank.exe" , "-o" , "--lf" ;
}
command_provider ! {
TERMUX ,
yank = > "termux-clipboard-set" ;
paste = > "termux-clipboard-get" ;
} }
#[ cfg(not(target_arch = " wasm32 " )) ] #[ cfg(feature = " term " ) ]
pub mod command { mod osc52 {
use super ::* ; use { super ::ClipboardType , crate ::base64 } ;
use anyhow ::{ bail , Context as _ } ;
#[ cfg(not(any(windows, target_os = " macos " ))) ] pub struct SetClipboardCommand {
pub fn is_exit_success ( program : & str , args : & [ & str ] ) -> bool { encoded_content : String ,
std ::process ::Command ::new ( program ) clipboard_type : ClipboardType ,
. args ( args )
. output ( )
. ok ( )
. and_then ( | out | out . status . success ( ) . then_some ( ( ) ) )
. is_some ( )
} }
#[ derive(Debug) ] impl SetClipboardCommand {
pub struct Config { pub fn new ( content : & str , clipboard_type : ClipboardType ) -> Self {
pub prg : & ' static str , Self {
pub args : & ' static [ & ' static str ] , encoded_content : base64 ::encode ( content . as_bytes ( ) ) ,
clipboard_type ,
}
}
} }
impl Config { impl crossterm ::Command for SetClipboardCommand {
fn execute ( & self , input : Option < & str > , pipe_output : bool ) -> Result < Option < String > > { fn write_ansi ( & self , f : & mut impl std ::fmt ::Write ) -> std ::fmt ::Result {
let kind = match & self . clipboard_type {
ClipboardType ::Clipboard = > "c" ,
ClipboardType ::Selection = > "p" ,
} ;
// Send an OSC 52 set command: https://terminalguide.namepad.de/seq/osc-52/
write! ( f , "\x1b]52;{};{}\x1b\\" , kind , & self . encoded_content )
}
#[ cfg(windows) ]
fn execute_winapi ( & self ) -> std ::result ::Result < ( ) , std ::io ::Error > {
Err ( std ::io ::Error ::new (
std ::io ::ErrorKind ::Other ,
"OSC clipboard codes not supported by winapi." ,
) )
}
}
}
fn execute_command (
cmd : & Command ,
input : Option < & str > ,
pipe_output : bool ,
) -> Result < Option < String > > {
use std ::io ::Write ; use std ::io ::Write ;
use std ::process ::{ Command , Stdio } ; use std ::process ::{ Command , Stdio } ;
let stdin = input . map ( | _ | Stdio ::piped ( ) ) . unwrap_or_else ( Stdio ::null ) ; let stdin = input . map ( | _ | Stdio ::piped ( ) ) . unwrap_or_else ( Stdio ::null ) ;
let stdout = pipe_output . then ( Stdio ::piped ) . unwrap_or_else ( Stdio ::null ) ; let stdout = pipe_output . then ( Stdio ::piped ) . unwrap_or_else ( Stdio ::null ) ;
let mut command : Command = Command ::new ( self . prg ) ; let mut command : Command = Command ::new ( cmd . command . as_ref ( ) ) ;
#[ allow(unused_mut) ]
let mut command_mut : & mut Command = command let mut command_mut : & mut Command = command
. args ( self . args ) . args ( cmd . args . iter ( ) . map ( AsRef ::as_ref ) )
. stdin ( stdin ) . stdin ( stdin )
. stdout ( stdout ) . stdout ( stdout )
. stderr ( Stdio ::null ( ) ) ; . stderr ( Stdio ::null ( ) ) ;
// Fix for https://github.com/helix-editor/helix/issues/5424
// Fix for https://github.com/helix-editor/helix/issues/5424
if cfg! ( unix ) { #[ cfg(unix) ]
{
use std ::os ::unix ::process ::CommandExt ; use std ::os ::unix ::process ::CommandExt ;
unsafe { unsafe {
@ -304,17 +472,22 @@ pub mod provider {
let mut child = command_mut . spawn ( ) ? ; let mut child = command_mut . spawn ( ) ? ;
if let Some ( input ) = input { if let Some ( input ) = input {
let mut stdin = child . stdin . take ( ) . context( "stdin is missing" ) ? ; let mut stdin = child . stdin . take ( ) . ok_or( ClipboardError ::StdinWriteFailed ) ? ;
stdin stdin
. write_all ( input . as_bytes ( ) ) . write_all ( input . as_bytes ( ) )
. context ( "couldn't write in stdin" ) ? ; . map_err ( | _ | ClipboardError ::StdinWriteFailed ) ? ;
} }
// TODO: add timer?
// TODO: add timer?
let output = child . wait_with_output ( ) ? ; let output = child . wait_with_output ( ) ? ;
if ! output . status . success ( ) { if ! output . status . success ( ) {
bail ! ( "clipboard provider {} failed" , self . prg ) ; log ::error ! (
"clipboard provider {} failed with stderr: \"{}\"" ,
cmd . command ,
String ::from_utf8_lossy ( & output . stderr )
) ;
return Err ( ClipboardError ::CommandFailed ) ;
} }
if pipe_output { if pipe_output {
@ -324,90 +497,3 @@ pub mod provider {
} }
} }
} }
#[ derive(Debug) ]
pub struct Provider {
pub get_cmd : Config ,
pub set_cmd : Config ,
pub get_primary_cmd : Option < Config > ,
pub set_primary_cmd : Option < Config > ,
}
impl ClipboardProvider for Provider {
fn name ( & self ) -> Cow < str > {
if self . get_cmd . prg ! = self . set_cmd . prg {
Cow ::Owned ( format! ( "{}+{}" , self . get_cmd . prg , self . set_cmd . prg ) )
} else {
Cow ::Borrowed ( self . get_cmd . prg )
}
}
fn get_contents ( & self , clipboard_type : ClipboardType ) -> Result < String > {
match clipboard_type {
ClipboardType ::Clipboard = > Ok ( self
. get_cmd
. execute ( None , true ) ?
. context ( "output is missing" ) ? ) ,
ClipboardType ::Selection = > {
if let Some ( cmd ) = & self . get_primary_cmd {
return cmd . execute ( None , true ) ? . context ( "output is missing" ) ;
}
Ok ( String ::new ( ) )
}
}
}
fn set_contents ( & mut self , value : String , clipboard_type : ClipboardType ) -> Result < ( ) > {
let cmd = match clipboard_type {
ClipboardType ::Clipboard = > & self . set_cmd ,
ClipboardType ::Selection = > {
if let Some ( cmd ) = & self . set_primary_cmd {
cmd
} else {
return Ok ( ( ) ) ;
}
}
} ;
cmd . execute ( Some ( & value ) , false ) . map ( | _ | ( ) )
}
}
}
}
#[ cfg(target_os = " windows " ) ]
mod provider {
use super ::{ ClipboardProvider , ClipboardType } ;
use anyhow ::Result ;
use std ::borrow ::Cow ;
#[ derive(Default, Debug) ]
pub struct WindowsProvider ;
impl ClipboardProvider for WindowsProvider {
fn name ( & self ) -> Cow < str > {
log ::debug ! ( "Using clipboard-win to interact with the system clipboard" ) ;
Cow ::Borrowed ( "clipboard-win" )
}
fn get_contents ( & self , clipboard_type : ClipboardType ) -> Result < String > {
match clipboard_type {
ClipboardType ::Clipboard = > {
let contents = clipboard_win ::get_clipboard ( clipboard_win ::formats ::Unicode ) ? ;
Ok ( contents )
}
ClipboardType ::Selection = > Ok ( String ::new ( ) ) ,
}
}
fn set_contents ( & mut self , contents : String , clipboard_type : ClipboardType ) -> Result < ( ) > {
match clipboard_type {
ClipboardType ::Clipboard = > {
clipboard_win ::set_clipboard ( clipboard_win ::formats ::Unicode , contents ) ? ;
}
ClipboardType ::Selection = > { }
} ;
Ok ( ( ) )
}
}
}
Alfie Richards
1 day ago
committed by
GitHub