lintel_explain/

lib.rs

#![doc = include_str!("../README.md")]

extern crate alloc;

mod inline;
mod path;
pub mod resolve;

pub use resolve::{ResolvedFileSchema, SchemaSource, build_retriever};

use std::io::IsTerminal;
use std::path::{Path, PathBuf};

use anyhow::{Context, Result};
use bpaf::{Bpaf, ShellComp};

use lintel_cli_common::{CLIGlobalOptions, CliCacheOptions};

// ---------------------------------------------------------------------------
// CLI args
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Bpaf)]
#[bpaf(generate(explain_args_inner))]
pub struct ExplainArgs {
    /// Schema URL or local file path to explain.
    /// Can be combined with `--file` or `--path` to override schema resolution
    /// while still validating the data file.
    #[bpaf(long("schema"), argument("URL|FILE"), complete_shell(ShellComp::File { mask: None }))]
    pub schema: Option<String>,

    /// Data file (local path or URL) to resolve the schema from and validate.
    /// The file must exist (or be fetchable). For URLs, the filename is used
    /// for catalog matching.
    #[bpaf(long("file"), argument("FILE|URL"), complete_shell(ShellComp::File { mask: None }))]
    pub file: Option<String>,

    /// File path or URL to resolve the schema from using catalogs.
    /// Local files need not exist; if the file exists (or is a URL), it is
    /// also validated.
    #[bpaf(long("path"), argument("FILE|URL"), complete_shell(ShellComp::File { mask: None }))]
    pub resolve_path: Option<String>,

    #[bpaf(external(lintel_cli_common::cli_cache_options))]
    pub cache: CliCacheOptions,

    /// Disable syntax highlighting in code blocks
    #[bpaf(long("no-syntax-highlighting"), switch)]
    pub no_syntax_highlighting: bool,

    /// Print output directly instead of piping through a pager
    #[bpaf(long("no-pager"), switch)]
    pub no_pager: bool,

    /// Show extended details like $comment annotations
    #[bpaf(long("extended"), switch)]
    pub extended: bool,

    /// First positional argument. When no `--file`, `--path`, or `--schema`
    /// flag is given this is treated as a file path (equivalent to `--path`).
    /// Otherwise it is a JSON Pointer or `JSONPath` to a sub-schema.
    ///
    /// Examples:
    /// - `lintel explain package.json`       — explains the schema for `package.json`
    /// - `lintel explain --file f.yaml name`  — explains the `name` property
    #[bpaf(positional("FILE|POINTER"), complete_shell(ShellComp::File { mask: None }))]
    pub positional: Option<String>,

    /// JSON Pointer (`/properties/name`) or `JSONPath` (`$.name`) to a sub-schema.
    /// Only used when the first positional is a file path.
    ///
    /// Example: `lintel explain package.json name`
    #[bpaf(positional("POINTER"))]
    pub pointer: Option<String>,
}

/// Construct the bpaf parser for `ExplainArgs`.
pub fn explain_args() -> impl bpaf::Parser<ExplainArgs> {
    explain_args_inner()
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

fn is_url(s: &str) -> bool {
    s.starts_with("http://") || s.starts_with("https://")
}

/// Split a schema URI into the base URL and an optional fragment pointer.
///
/// Uses the `url` crate for proper URL parsing when the input is a URL.
/// For local file paths, falls back to simple `#` splitting.
///
/// e.g. `"https://example.com/s.json#/$defs/Foo"` → `("https://example.com/s.json", Some("/$defs/Foo"))`
fn split_schema_fragment(schema: &str) -> (String, Option<String>) {
    if is_url(schema)
        && let Ok(parsed) = url::Url::parse(schema)
    {
        let fragment = parsed
            .fragment()
            .map(String::from)
            .filter(|f| !f.is_empty());
        let mut base = parsed;
        base.set_fragment(None);
        return (base.to_string(), fragment);
    }
    // Local file path: simple split on '#'
    if let Some(pos) = schema.find('#') {
        let frag = &schema[pos + 1..];
        let base = schema[..pos].to_string();
        if frag.is_empty() {
            (base, None)
        } else {
            (base, Some(frag.to_string()))
        }
    } else {
        (schema.to_string(), None)
    }
}

/// Extract the last path segment from a URL, e.g. "package.json".
fn url_filename(url: &str) -> String {
    url.rsplit('/')
        .next()
        .and_then(|seg| {
            // Strip query string / fragment
            let seg = seg.split('?').next().unwrap_or(seg);
            let seg = seg.split('#').next().unwrap_or(seg);
            if seg.is_empty() {
                None
            } else {
                Some(seg.to_string())
            }
        })
        .unwrap_or_else(|| "file".to_string())
}

/// Fetch URL content via HTTP GET.
async fn fetch_url_content(url: &str) -> Result<String> {
    let resp = reqwest::get(url)
        .await
        .with_context(|| format!("failed to fetch URL: {url}"))?;
    let status = resp.status();
    if !status.is_success() {
        anyhow::bail!("HTTP {status} fetching {url}");
    }
    resp.text()
        .await
        .with_context(|| format!("failed to read response body from {url}"))
}

/// Data fetched from a remote URL.
struct FetchedData {
    content: String,
    filename: String,
}

/// Temporary file used to give the validation pipeline a real file path with
/// the correct filename for catalog matching. Cleaned up on drop.
struct TempDataFile {
    _dir: tempfile::TempDir,
    file_path: PathBuf,
}

impl TempDataFile {
    fn new(filename: &str, content: &str) -> Result<Self> {
        let dir = tempfile::tempdir().context("failed to create temp directory")?;
        let file_path = dir.path().join(filename);
        std::fs::write(&file_path, content)
            .with_context(|| format!("failed to write temp file: {}", file_path.display()))?;
        Ok(Self {
            _dir: dir,
            file_path,
        })
    }
}

// ---------------------------------------------------------------------------
// Entry point
// ---------------------------------------------------------------------------

/// Run the explain command.
///
/// # Errors
///
/// Returns an error if the schema cannot be fetched, parsed, or the pointer
/// cannot be resolved.
#[allow(clippy::missing_panics_doc)]
pub async fn run(args: ExplainArgs, global: &CLIGlobalOptions) -> Result<bool> {
    // Normalize positional args: when no flag is given, the first positional
    // is a file path (equivalent to --path) and the second is the pointer.
    let has_flag = args.file.is_some() || args.resolve_path.is_some() || args.schema.is_some();
    let mut args = args;

    // Extract fragment from --schema if present (e.g., URL#/$defs/Foo).
    // The fragment is used as the pointer to navigate into the schema.
    let schema_fragment = if let Some(schema) = args.schema.take() {
        let (base, frag) = split_schema_fragment(&schema);
        args.schema = Some(base);
        frag
    } else {
        None
    };

    let pointer_str = if has_flag {
        // Flags present: first positional is the pointer, second is invalid.
        if args.pointer.is_some() {
            anyhow::bail!("unexpected extra positional argument");
        }
        // Explicit positional pointer takes precedence over schema fragment.
        args.positional.take().or(schema_fragment)
    } else if args.positional.is_some() {
        // No flags: first positional is the file path.
        args.resolve_path = args.positional.take();
        args.pointer.take()
    } else {
        anyhow::bail!(
            "a file path or one of --file <FILE>, --path <FILE>, --schema <URL|FILE> is required"
        );
    };

    let data_source_str = args.file.as_deref().or(args.resolve_path.as_deref());
    let is_file_flag = args.file.is_some();

    let fetched = fetch_data_source(data_source_str).await?;

    let (schema_uri, display_name, is_remote) =
        resolve_schema_info(&args, data_source_str, is_file_flag, fetched.as_ref()).await?;

    let schema = fetch_schema(&schema_uri, is_remote, &args.cache).await?;
    let schema_value = jsonschema_schema::SchemaValue::Schema(Box::new(schema));

    let pointer = pointer_str
        .as_deref()
        .map(path::to_schema_pointer)
        .transpose()
        .map_err(|e| anyhow::anyhow!("{e}"))?;

    let instance_prefix = pointer
        .as_deref()
        .map(schema_pointer_to_instance_prefix)
        .unwrap_or_default();

    let validation_errors = run_validation(
        fetched.as_ref(),
        data_source_str,
        &args.cache,
        &instance_prefix,
    )
    .await?;

    let is_tty = std::io::stdout().is_terminal();
    let use_color = global.use_color(is_tty);
    let opts = jsonschema_explain::ExplainOptions {
        color: use_color,
        syntax_highlight: use_color && !args.no_syntax_highlighting,
        width: lintel_cli_common::terminal_width(),
        validation_errors,
        extended: args.extended,
    };

    // When navigating via pointer, use the last path segment as the display
    // name (e.g. "compilerOptionsDefinition" instead of the full URL).
    let display_name = if let Some(ref ptr) = pointer {
        ptr.rsplit('/')
            .next()
            .filter(|s| !s.is_empty())
            .unwrap_or(&display_name)
            .to_string()
    } else {
        display_name
    };

    let output = match pointer.as_deref() {
        Some(ptr) => jsonschema_explain::explain_at_path(&schema_value, ptr, &display_name, &opts)
            .map_err(|e| anyhow::anyhow!("{e}"))?,
        None => jsonschema_explain::explain(&schema_value, &display_name, &opts),
    };

    if is_tty && !args.no_pager {
        lintel_cli_common::pipe_to_pager(&output);
    } else {
        print!("{output}");
    }

    Ok(false)
}

// ---------------------------------------------------------------------------
// Shared explain helper for `lintel identify --explain`
// ---------------------------------------------------------------------------

/// Display options for rendering schema documentation.
pub struct ExplainDisplayArgs {
    /// Disable syntax highlighting in code blocks.
    pub no_syntax_highlighting: bool,
    /// Print output directly instead of piping through a pager.
    pub no_pager: bool,
    /// Show extended details like `$comment` annotations.
    pub extended: bool,
}

/// Fetch, migrate, and render schema documentation for an already-resolved
/// schema. Used by `lintel identify --explain`.
///
/// # Errors
///
/// Returns an error if the schema cannot be fetched or deserialized.
pub async fn explain_resolved_schema(
    resolved: &ResolvedFileSchema,
    cache: &CliCacheOptions,
    global: &CLIGlobalOptions,
    display: &ExplainDisplayArgs,
) -> Result<()> {
    match fetch_schema(&resolved.schema_uri, resolved.is_remote, cache).await {
        Ok(schema) => {
            let sv = jsonschema_schema::SchemaValue::Schema(Box::new(schema));
            let is_tty = std::io::stdout().is_terminal();
            let use_color = global.use_color(is_tty);
            let opts = jsonschema_explain::ExplainOptions {
                color: use_color,
                syntax_highlight: use_color && !display.no_syntax_highlighting,
                width: lintel_cli_common::terminal_width(),
                validation_errors: vec![],
                extended: display.extended,
            };
            let output = jsonschema_explain::explain(&sv, &resolved.display_name, &opts);
            if is_tty && !display.no_pager {
                lintel_cli_common::pipe_to_pager(&format!("\n{output}"));
            } else {
                println!();
                print!("{output}");
            }
            Ok(())
        }
        Err(e) => {
            eprintln!("  error fetching schema: {e}");
            Ok(())
        }
    }
}

/// If the data source is a URL, fetch its content; otherwise return `None`.
async fn fetch_data_source(data_source_str: Option<&str>) -> Result<Option<FetchedData>> {
    let Some(src) = data_source_str else {
        return Ok(None);
    };
    if !is_url(src) {
        return Ok(None);
    }
    let content = fetch_url_content(src).await?;
    let filename = url_filename(src);
    Ok(Some(FetchedData { content, filename }))
}

/// Determine the schema URI, display name, and whether it's remote.
async fn resolve_schema_info(
    args: &ExplainArgs,
    data_source_str: Option<&str>,
    is_file_flag: bool,
    fetched: Option<&FetchedData>,
) -> Result<(String, String, bool)> {
    if let Some(ref schema) = args.schema {
        let is_remote = is_url(schema);
        if !is_remote && !is_url(data_source_str.unwrap_or("")) {
            let resolved = data_source_str
                .map(Path::new)
                .and_then(|p| p.parent())
                .map_or_else(
                    || schema.clone(),
                    |parent| parent.join(schema).to_string_lossy().to_string(),
                );
            Ok((resolved.clone(), resolved, false))
        } else {
            Ok((schema.clone(), schema.clone(), is_remote))
        }
    } else if let Some(fetched) = fetched {
        let cwd = std::env::current_dir().ok();
        let virtual_path = PathBuf::from(&fetched.filename);
        let resolved = resolve::resolve_schema_for_content(
            &fetched.content,
            &virtual_path,
            cwd.as_deref(),
            &args.cache,
        )
        .await?
        .ok_or_else(|| {
            anyhow::anyhow!("no schema found for URL: {}", data_source_str.unwrap_or(""))
        })?;
        Ok((
            resolved.schema_uri,
            resolved.display_name,
            resolved.is_remote,
        ))
    } else if let Some(src) = data_source_str {
        resolve_local_schema(src, is_file_flag, &args.cache).await
    } else {
        unreachable!("at least --schema is set (checked above)")
    }
}

/// Resolve schema from a local file or path.
async fn resolve_local_schema(
    src: &str,
    is_file_flag: bool,
    cache: &CliCacheOptions,
) -> Result<(String, String, bool)> {
    let path = Path::new(src);
    if path.exists() {
        let resolved = resolve::resolve_schema_for_file(path, cache)
            .await?
            .ok_or_else(|| anyhow::anyhow!("no schema found for {src}"))?;
        Ok((
            resolved.schema_uri,
            resolved.display_name,
            resolved.is_remote,
        ))
    } else if is_file_flag {
        anyhow::bail!("file not found: {src}");
    } else {
        let resolved = resolve::resolve_schema_for_path(path, cache)
            .await?
            .ok_or_else(|| anyhow::anyhow!("no schema found for path: {src}"))?;
        Ok((
            resolved.schema_uri,
            resolved.display_name,
            resolved.is_remote,
        ))
    }
}

/// Collect validation errors from the data source if available.
async fn run_validation(
    fetched: Option<&FetchedData>,
    data_source_str: Option<&str>,
    cache: &CliCacheOptions,
    instance_prefix: &str,
) -> Result<Vec<jsonschema_explain::ExplainError>> {
    if let Some(fetched) = fetched {
        let temp = TempDataFile::new(&fetched.filename, &fetched.content)?;
        let config_dir = std::env::current_dir().ok();
        Ok(collect_validation_errors(
            &temp.file_path.to_string_lossy(),
            cache,
            instance_prefix,
            config_dir,
        )
        .await)
    } else if let Some(src) = data_source_str {
        if Path::new(src).exists() {
            Ok(collect_validation_errors(src, cache, instance_prefix, None).await)
        } else {
            Ok(vec![])
        }
    } else {
        Ok(vec![])
    }
}

async fn fetch_schema(
    schema_uri: &str,
    is_remote: bool,
    cache: &CliCacheOptions,
) -> Result<jsonschema_schema::Schema> {
    let retriever = resolve::build_retriever(cache);
    let mut value: serde_json::Value = if is_remote {
        let (val, _) = retriever
            .fetch(schema_uri)
            .await
            .map_err(|e| anyhow::anyhow!("failed to fetch schema '{schema_uri}': {e}"))?;
        val
    } else {
        let content = std::fs::read_to_string(schema_uri)
            .with_context(|| format!("failed to read schema: {schema_uri}"))?;
        serde_json::from_str(&content)
            .with_context(|| format!("failed to parse schema: {schema_uri}"))?
    };

    inline::inline_external_refs(&mut value, schema_uri, &retriever).await?;
    jsonschema_migrate::migrate_to_2020_12(&mut value);
    let json_string = serde_json::to_string(&value)
        .with_context(|| format!("failed to serialize schema: {schema_uri}"))?;
    let mut jd = serde_json::Deserializer::from_str(&json_string);
    serde_path_to_error::deserialize(&mut jd)
        .with_context(|| format!("failed to deserialize schema: {schema_uri}"))
}

/// Convert a schema pointer (e.g. `/properties/badges`) to an instance path
/// prefix (e.g. `/badges`) by stripping `/properties/` segments.
fn schema_pointer_to_instance_prefix(schema_pointer: &str) -> String {
    let mut result = String::new();
    let mut segments = schema_pointer.split('/').peekable();
    // Skip the leading empty segment from the leading `/`.
    segments.next();
    while let Some(seg) = segments.next() {
        if seg == "properties" {
            // The next segment is the actual property name.
            if let Some(prop) = segments.next() {
                result.push('/');
                result.push_str(prop);
            }
        } else if seg == "items" {
            // Array items — keep descending but don't add to the prefix.
        } else {
            result.push('/');
            result.push_str(seg);
        }
    }
    result
}

/// Run validation on a data file and return errors filtered to a given
/// instance path prefix.
async fn collect_validation_errors(
    file_path: &str,
    cache: &CliCacheOptions,
    instance_prefix: &str,
    config_dir: Option<PathBuf>,
) -> Vec<jsonschema_explain::ExplainError> {
    let validate_args = lintel_validate::validate::ValidateArgs {
        globs: vec![file_path.to_string()],
        exclude: vec![],
        cache_dir: cache.cache_dir.clone(),
        force_schema_fetch: cache.force_schema_fetch || cache.force,
        force_validation: false,
        no_catalog: cache.no_catalog,
        config_dir,
        schema_cache_ttl: cache.schema_cache_ttl,
    };

    let result = match lintel_validate::validate::run(&validate_args).await {
        Ok(r) => r,
        Err(e) => {
            tracing::debug!("validation failed: {e}");
            return vec![];
        }
    };

    result
        .errors
        .into_iter()
        .filter_map(|err| {
            if let lintel_diagnostics::LintelDiagnostic::Validation(v) = err {
                // When explaining the root, show all errors.
                // Otherwise only show errors under the given property.
                if instance_prefix.is_empty()
                    || v.instance_path == instance_prefix
                    || v.instance_path.starts_with(&format!("{instance_prefix}/"))
                {
                    Some(jsonschema_explain::ExplainError {
                        instance_path: v.instance_path,
                        message: v.message,
                    })
                } else {
                    None
                }
            } else {
                None
            }
        })
        .collect()
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
    use super::*;
    use bpaf::Parser;
    use lintel_cli_common::cli_global_options;

    fn test_cli() -> bpaf::OptionParser<(CLIGlobalOptions, ExplainArgs)> {
        bpaf::construct!(cli_global_options(), explain_args())
            .to_options()
            .descr("test explain args")
    }

    #[test]
    fn cli_parses_schema_only() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--schema", "https://example.com/schema.json"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(
            args.schema.as_deref(),
            Some("https://example.com/schema.json")
        );
        assert!(args.file.is_none());
        assert!(args.positional.is_none());
        Ok(())
    }

    #[test]
    fn cli_parses_file_with_pointer() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--file", "config.yaml", "/properties/name"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.file.as_deref(), Some("config.yaml"));
        assert_eq!(args.positional.as_deref(), Some("/properties/name"));
        Ok(())
    }

    #[test]
    fn cli_parses_schema_with_jsonpath() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--schema", "schema.json", "$.name"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.schema.as_deref(), Some("schema.json"));
        assert_eq!(args.positional.as_deref(), Some("$.name"));
        Ok(())
    }

    #[test]
    fn cli_parses_display_options() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&[
                "--schema",
                "s.json",
                "--no-syntax-highlighting",
                "--no-pager",
            ])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert!(args.no_syntax_highlighting);
        assert!(args.no_pager);
        Ok(())
    }

    #[test]
    fn cli_parses_path_only() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--path", "tsconfig.json"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.resolve_path.as_deref(), Some("tsconfig.json"));
        assert!(args.file.is_none());
        assert!(args.schema.is_none());
        assert!(args.positional.is_none());
        Ok(())
    }

    #[test]
    fn cli_parses_path_with_pointer() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--path", "config.yaml", "/properties/name"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.resolve_path.as_deref(), Some("config.yaml"));
        assert_eq!(args.positional.as_deref(), Some("/properties/name"));
        Ok(())
    }

    #[test]
    fn cli_parses_path_with_jsonpath() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--path", "config.yaml", "$.name"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.resolve_path.as_deref(), Some("config.yaml"));
        assert_eq!(args.positional.as_deref(), Some("$.name"));
        Ok(())
    }

    #[test]
    fn cli_file_takes_precedence_over_path() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--file", "data.yaml", "--path", "other.yaml"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.file.as_deref(), Some("data.yaml"));
        assert_eq!(args.resolve_path.as_deref(), Some("other.yaml"));
        // Both are parsed — precedence is enforced at runtime in run()
        Ok(())
    }

    #[test]
    fn cli_path_takes_precedence_over_schema() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--path", "config.yaml", "--schema", "s.json"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.resolve_path.as_deref(), Some("config.yaml"));
        assert_eq!(args.schema.as_deref(), Some("s.json"));
        // Both are parsed — precedence is enforced at runtime in run()
        Ok(())
    }

    #[test]
    fn cli_schema_with_file() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--schema", "s.json", "--file", "data.yaml"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.schema.as_deref(), Some("s.json"));
        assert_eq!(args.file.as_deref(), Some("data.yaml"));
        Ok(())
    }

    #[test]
    fn cli_schema_with_path() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["--schema", "s.json", "--path", "data.yaml"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.schema.as_deref(), Some("s.json"));
        assert_eq!(args.resolve_path.as_deref(), Some("data.yaml"));
        Ok(())
    }

    #[tokio::test]
    async fn run_rejects_no_source() {
        let args = ExplainArgs {
            schema: None,
            file: None,
            resolve_path: None,
            cache: CliCacheOptions {
                cache_dir: None,
                schema_cache_ttl: None,
                force_schema_fetch: false,
                force_validation: false,
                force: false,
                no_catalog: false,
            },
            no_syntax_highlighting: false,
            no_pager: false,
            extended: false,
            positional: None,
            pointer: None,
        };
        let global = CLIGlobalOptions {
            colors: None,
            verbose: false,
            log_level: lintel_cli_common::LogLevel::None,
        };
        let err = run(args, &global).await.unwrap_err();
        assert!(
            err.to_string().contains("a file path or one of --file"),
            "unexpected error: {err}"
        );
    }

    #[test]
    fn cli_parses_cache_options() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&[
                "--schema",
                "s.json",
                "--cache-dir",
                "/tmp/cache",
                "--no-catalog",
            ])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.cache.cache_dir.as_deref(), Some("/tmp/cache"));
        assert!(args.cache.no_catalog);
        Ok(())
    }

    // --- positional-only usage ---

    #[test]
    fn cli_positional_file_only() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["package.json"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.positional.as_deref(), Some("package.json"));
        assert!(args.pointer.is_none());
        assert!(args.file.is_none());
        assert!(args.resolve_path.is_none());
        assert!(args.schema.is_none());
        Ok(())
    }

    #[test]
    fn cli_positional_file_with_pointer() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["package.json", "name"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.positional.as_deref(), Some("package.json"));
        assert_eq!(args.pointer.as_deref(), Some("name"));
        assert!(args.file.is_none());
        assert!(args.resolve_path.is_none());
        assert!(args.schema.is_none());
        Ok(())
    }

    #[test]
    fn cli_positional_file_with_json_pointer() -> anyhow::Result<()> {
        let (_, args) = test_cli()
            .run_inner(&["config.yaml", "/properties/name"])
            .map_err(|e| anyhow::anyhow!("{e:?}"))?;
        assert_eq!(args.positional.as_deref(), Some("config.yaml"));
        assert_eq!(args.pointer.as_deref(), Some("/properties/name"));
        Ok(())
    }

    // --- URL filename extraction ---

    #[test]
    fn url_filename_simple() {
        assert_eq!(
            url_filename("https://example.com/package.json"),
            "package.json"
        );
    }

    #[test]
    fn url_filename_with_query() {
        assert_eq!(
            url_filename("https://example.com/config.yaml?ref=main"),
            "config.yaml"
        );
    }

    #[test]
    fn url_filename_with_fragment() {
        assert_eq!(
            url_filename("https://example.com/config.yaml#section"),
            "config.yaml"
        );
    }

    #[test]
    fn url_filename_nested_path() {
        assert_eq!(
            url_filename(
                "https://raw.githubusercontent.com/org/repo/main/.github/workflows/ci.yml"
            ),
            "ci.yml"
        );
    }

    #[test]
    fn url_filename_trailing_slash() {
        assert_eq!(url_filename("https://example.com/"), "file");
    }

    // --- is_url ---

    #[test]
    fn is_url_detects_https() {
        assert!(is_url("https://example.com/schema.json"));
    }

    #[test]
    fn is_url_detects_http() {
        assert!(is_url("http://example.com/schema.json"));
    }

    #[test]
    fn is_url_rejects_local() {
        assert!(!is_url("./schema.json"));
        assert!(!is_url("/tmp/schema.json"));
        assert!(!is_url("schema.json"));
    }

    // --- split_schema_fragment ---

    #[test]
    fn fragment_extracted_from_url() {
        let (base, frag) = split_schema_fragment("https://example.com/s.json#/$defs/Foo");
        assert_eq!(base, "https://example.com/s.json");
        assert_eq!(frag.as_deref(), Some("/$defs/Foo"));
    }

    #[test]
    fn no_fragment_returns_none() {
        let (base, frag) = split_schema_fragment("https://example.com/s.json");
        assert_eq!(base, "https://example.com/s.json");
        assert_eq!(frag, None);
    }

    #[test]
    fn empty_fragment_returns_none() {
        let (base, frag) = split_schema_fragment("https://example.com/s.json#");
        assert_eq!(base, "https://example.com/s.json");
        assert_eq!(frag, None);
    }

    #[test]
    fn local_file_with_fragment() {
        let (base, frag) = split_schema_fragment("./schema.json#/$defs/Bar");
        assert_eq!(base, "./schema.json");
        assert_eq!(frag.as_deref(), Some("/$defs/Bar"));
    }
}