Struct DocumentState 

pub struct DocumentState {
    pub ecosystem: Ecosystem,
    pub ecosystem_id: &'static str,
    pub content: String,
    pub dependencies: Vec<UnifiedDependency>,
    pub versions: HashMap<String, UnifiedVersion>,
    pub cached_versions: HashMap<String, String>,
    pub resolved_versions: HashMap<String, String>,
    pub parsed_at: Instant,
    pub loading_state: LoadingState,
    pub loading_started_at: Option<Instant>,
    /* private fields */
}

State for a single open document.

Stores the document content, parsed dependency information, and cached version data for a single file. The state is updated when the document changes or when version information is fetched from the registry.

Supports multiple package ecosystems (Cargo, npm) with unified dependency and version storage.

Examples

use deps_lsp::document::{DocumentState, Ecosystem, UnifiedDependency};
use deps_lsp::ParsedDependency;
use deps_cargo::{DependencySection, DependencySource};
use tower_lsp_server::ls_types::{Position, Range};

let dep = ParsedDependency {
    name: "serde".into(),
    name_range: Range::new(Position::new(0, 0), Position::new(0, 5)),
    version_req: Some("1.0".into()),
    version_range: Some(Range::new(Position::new(0, 8), Position::new(0, 12))),
    features: vec![],
    features_range: None,
    source: DependencySource::Registry,
    workspace_inherited: false,
    section: DependencySection::Dependencies,
};

let state = DocumentState::new(
    Ecosystem::Cargo,
    "[dependencies]\nserde = \"1.0\"".into(),
    vec![UnifiedDependency::Cargo(dep)],
);

assert!(state.versions.is_empty());
assert_eq!(state.dependencies.len(), 1);

Fields

ecosystem: Ecosystem

Package ecosystem type (deprecated, use ecosystem_id)

ecosystem_id: &'static str

Ecosystem identifier (“cargo”, “npm”, “pypi”)

content: String

Original document content

dependencies: Vec<UnifiedDependency>

Parsed dependencies with positions (legacy)

versions: HashMap<String, UnifiedVersion>

Cached latest version information from registry

cached_versions: HashMap<String, String>

Simplified cached versions (just strings) for new architecture

resolved_versions: HashMap<String, String>

Resolved versions from lock file

parsed_at: Instant

Last successful parse time

loading_state: LoadingState

Current loading state for registry data

loading_started_at: Option<Instant>

When the current loading operation started (for timeout/metrics)

Implementations

impl DocumentState

pub fn new( ecosystem: Ecosystem, content: String, dependencies: Vec<UnifiedDependency>, ) -> Self

Creates a new document state (legacy constructor).

Initializes with the given ecosystem, content, and parsed dependencies. Version information starts empty and is populated asynchronously.

pub fn new_from_parse_result( ecosystem_id: &'static str, content: String, parse_result: Box<dyn ParseResult>, ) -> Self

Creates a new document state using trait objects (new architecture).

This is the preferred constructor for Phase 3+ implementations.

pub fn new_without_parse_result( ecosystem_id: &'static str, content: String, ) -> Self

Creates a new document state without a parse result.

Used when parsing fails but the document should still be stored to enable fallback completion and other LSP features.

pub fn parse_result(&self) -> Option<&dyn ParseResult>

Gets a reference to the parse result if available.

pub fn update_versions(&mut self, versions: HashMap<String, UnifiedVersion>)

Updates the cached latest version information for dependencies.

pub fn update_cached_versions(&mut self, versions: HashMap<String, String>)

Updates the simplified cached versions (new architecture).

pub fn update_resolved_versions(&mut self, versions: HashMap<String, String>)

Updates the resolved versions from lock file.

pub fn set_loading(&mut self)

Mark document as loading registry data.

Examples

use deps_lsp::document::DocumentState;

let mut doc = DocumentState::new_without_parse_result("cargo", "".into());
doc.set_loading();
assert!(doc.loading_started_at.is_some());

Thread Safety

This method requires exclusive access (&mut self). When used with DashMap::get_mut(), thread safety is guaranteed by the lock. Calling while already Loading resets the timer.

pub fn set_loaded(&mut self)

Mark document as loaded with fresh data.

Examples

use deps_lsp::document::{DocumentState, LoadingState};

let mut doc = DocumentState::new_without_parse_result("cargo", "".into());
doc.set_loading();
doc.set_loaded();
assert_eq!(doc.loading_state, LoadingState::Loaded);
assert!(doc.loading_started_at.is_none());

pub fn set_failed(&mut self)

Mark document as failed to load (keeps old cached data).

Examples

use deps_lsp::document::{DocumentState, LoadingState};

let mut doc = DocumentState::new_without_parse_result("cargo", "".into());
doc.set_loading();
doc.set_failed();
assert_eq!(doc.loading_state, LoadingState::Failed);
assert!(doc.loading_started_at.is_none());

pub fn loading_duration(&self) -> Option<Duration>

Get current loading duration if loading.

Returns None if not currently loading, or Some(Duration) representing how long the current loading operation has been running.

Examples

use deps_lsp::document::DocumentState;

let mut doc = DocumentState::new_without_parse_result("cargo", "".into());
assert!(doc.loading_duration().is_none());

doc.set_loading();
assert!(doc.loading_duration().is_some());

Trait Implementations

impl Clone for DocumentState

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DocumentState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.