use futures_util::FutureExt;

use helix_core::auto_pairs::AutoPairs;

use helix_core::chars::char_is_word;

use helix_core::diagnostic::DiagnosticProvider;

use helix_core::doc_formatter::TextFormat;

use helix_core::encoding::Encoding;

use helix_core::snippets::{ActiveSnippet, SnippetRenderCtx};

use helix_core::text_annotations::{InlineAnnotation, Overlay};

use helix_event::TaskController;

use helix_lsp::util::lsp_pos_to_pos;

history::{History, State, UndoKind},

indent::{auto_detect_indent_style, IndentStyle},

line_ending::auto_detect_line_ending,

ChangeSet, Diagnostic, LineEnding, Range, Rope, RopeBuilder, Selection, Syntax, Transaction,

};

use crate::{

editor::Config,

events::{DocumentDidChange, SelectionDidChange},

view::ViewPosition,

DocumentId, Editor, Theme, View, ViewId,

};

/// To know if they're up-to-date, check the `id` field in `DocumentInlayHints`.

pub(crate) inlay_hints: HashMap<ViewId, DocumentInlayHints>,

pub(crate) jump_labels: HashMap<ViewId, Vec<Overlay>>,

path: Option<PathBuf>,

relative_path: OnceCell<Option<PathBuf>>,

pub readonly: bool,

/// Annotations for LSP document color swatches

pub color_swatches: Option<DocumentColorSwatches>,

// NOTE: ideally this would live on the handler for color swatches. This is blocked on a

// large refactor that would make `&mut Editor` available on the `DocumentDidChange` event.

pub color_swatch_controller: TaskController,

}

#[derive(Debug, Clone, Default)]

pub struct DocumentColorSwatches {

pub color_swatches: Vec<InlineAnnotation>,

pub color_swatches_padding: Vec<InlineAnnotation>,

}

.field("id", &self.id)

.field("text", &self.text)

.field("selections", &self.selections)

.field("text_annotations", &self.inlay_hints)

.field("view_data", &self.view_data)

.field("path", &self.path)

text: Rope,

encoding_with_bom_info: Option<(&'static Encoding, bool)>,

config: Arc<dyn DynAccess<Config>>,

) -> Self {

let (encoding, has_bom) = encoding_with_bom_info.unwrap_or((encoding::UTF_8, false));

let line_ending = config.load().default_line_ending.into();

text,

selections: HashMap::default(),

inlay_hints: HashMap::default(),

view_data: Default::default(),

indent_style: DEFAULT_INDENT,

editor_config: EditorConfig::default(),

jump_labels: HashMap::new(),

color_swatches: None,

color_swatch_controller: TaskController::new(),

}

}

let line_ending: LineEnding = config.load().default_line_ending.into();

let text = Rope::from(line_ending.as_str());

}

// TODO: async fn?

pub fn open(

path: &Path,

mut encoding: Option<&'static Encoding>,

config: Arc<dyn DynAccess<Config>>,

) -> Result<Self, DocumentOpenError> {

// If the path is not a regular file (e.g.: /dev/random) it should not be opened.

if path.metadata().is_ok_and(|metadata| !metadata.is_file()) {

(Rope::from(line_ending.as_str()), encoding, false)

};

// set the path and try detecting the language

doc.set_path(Some(path));

}

doc.editor_config = editor_config;

/// The same as [`format`], but only returns formatting changes if auto-formatting

/// is configured.

if self.language_config()?.auto_format {

} else {

None

}

/// to format it nicely.

// We can't use anyhow::Result here since the output of the future has to be

// clonable to be used as shared future. So use a custom error type.

if let Some((fmt_cmd, fmt_args)) = self

.language_config()

.and_then(|c| c.formatter.as_ref())

process.current_dir(doc_dir);

}

process

.stdin(Stdio::piped())

.stdout(Stdio::piped())

.stderr(Stdio::piped());

} else if !output.stderr.is_empty() {

log::debug!(

"Formatter printed to stderr: {}",

);

}

};

let identifier = self.path().map(|_| self.identifier());

// mark changes up to now as saved

let current_rev = self.get_current_revision();

let doc_id = self.id();

let encoding_with_bom_info = (self.encoding, self.has_bom);

let last_saved_time = self.last_saved_time;

// Assume it is a hardlink to prevent data loss if the metadata cant be read (e.g. on certain Windows configurations)

let is_hardlink = helix_stdx::faccess::hardlink_count(&write_path).unwrap_or(2) > 1;

let path_ = write_path.clone();

// hacks: we use tempfile to handle the complex task of creating

// non clobbered temporary path for us we don't want

text: text.clone(),

};

if !language_server.is_initialized() {

continue;

}

}

/// Detect the programming language based on the file type.

}

/// Detect the programming language based on the file type.

pub fn detect_language_config(

&self,

}

/// Detect the indentation used in the file, or otherwise defaults to the language indentation

}

}

if self.config.load().editor_config {

if let Some(path) = self.path.as_ref() {

self.editor_config = EditorConfig::find(path);

/// if it exists.

pub fn set_language(

&mut self,

) {

}

/// Set the programming language for the file if you know the language but don't have the

pub fn set_language_by_language_id(

&mut self,

language_id: &str,

) -> anyhow::Result<()> {

.ok_or_else(|| anyhow!("invalid language id: {}", language_id))?;

Ok(())

}

// update tree-sitter syntax tree

if let Some(syntax) = &mut self.syntax {

old_doc.slice(..),

self.text.slice(..),

transaction.changes(),

self.syntax = None;

}

}

)

});

helix_event::dispatch(DocumentDidChange {

doc: self,

view: view_id,

let savepoint_idx = self

.savepoints

.iter()

.expect("Savepoint must belong to this document");

let savepoint_ref = self.savepoints.remove(savepoint_idx);

self.version

}

pub fn path_completion_enabled(&self) -> bool {

self.language_config()

.and_then(|lang_config| lang_config.path_completion)

viewport_width,

wrap_indicator: wrap_indicator.into_boxed_str(),

wrap_indicator_highlight: theme

soft_wrap_at_text_width,

}

}

self.inlay_hints.get(&view_id)

}

/// Completely removes all the inlay hints saved for the document, dropping them to free memory

/// (since it often means inlay hints have been fully deactivated).

pub fn reset_all_inlay_hints(&mut self) {

self.inlay_hints = Default::default();

}

}

#[derive(Debug, Default)]

text,

None,

Arc::new(ArcSwap::new(Arc::new(Config::default()))),

);

let view = ViewId::default();

doc.set_selection(view, Selection::single(0, 0));

text,

None,

Arc::new(ArcSwap::new(Arc::new(Config::default()))),

);

let view = ViewId::default();

doc.set_selection(view, Selection::single(5, 5));

#[test]

fn test_line_ending() {

assert_eq!(

helix_core::NATIVE_LINE_ENDING.as_str()

);

}