dprint 0.26.0

Binary for dprint code formatter—a pluggable and configurable code formatting platform.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use anyhow::Result;
use std::path::Path;
use std::path::PathBuf;

use crate::arg_parser::CliArgs;
use crate::arg_parser::SubCommand;
use crate::cache::Cache;
use crate::environment::CanonicalizedPathBuf;
use crate::environment::Environment;
use crate::utils::resolve_url_or_file_path;
use crate::utils::PathSource;
use crate::utils::ResolvedPath;

const DEFAULT_CONFIG_FILE_NAME: &str = "dprint.json";
const HIDDEN_CONFIG_FILE_NAME: &str = ".dprint.json";
const OLD_CONFIG_FILE_NAME: &str = ".dprintrc.json";

#[derive(Debug)]
pub struct ResolvedConfigPath {
  pub resolved_path: ResolvedPath,
  pub base_path: CanonicalizedPathBuf,
}

pub fn resolve_main_config_path<TEnvironment: Environment>(
  args: &CliArgs,
  cache: &Cache<TEnvironment>,
  environment: &TEnvironment,
) -> Result<ResolvedConfigPath> {
  return Ok(if let Some(config) = &args.config {
    let base_path = environment.cwd();
    let resolved_path = resolve_url_or_file_path(config, &PathSource::new_local(base_path.clone()), cache, environment)?;
    ResolvedConfigPath { resolved_path, base_path }
  } else {
    get_default_paths(args, environment)?
  });

  fn get_default_paths(args: &CliArgs, environment: &impl Environment) -> Result<ResolvedConfigPath> {
    let start_search_dir = get_start_search_directory(args, environment)?;
    let config_file_path = get_config_file_in_dir(&start_search_dir, environment);

    Ok(if let Some(config_file_path) = config_file_path {
      ResolvedConfigPath {
        resolved_path: ResolvedPath::local(environment.canonicalize(config_file_path)?),
        base_path: start_search_dir,
      }
    } else if let Some(resolved_config_path) = get_default_config_file_in_ancestor_directories(environment)? {
      resolved_config_path
    } else {
      // just return this even though it doesn't exist
      ResolvedConfigPath {
        resolved_path: ResolvedPath::local(environment.cwd().join_panic_relative(DEFAULT_CONFIG_FILE_NAME)),
        base_path: environment.cwd(),
      }
    })
  }

  fn get_start_search_directory(args: &CliArgs, environment: &impl Environment) -> Result<CanonicalizedPathBuf> {
    if let SubCommand::StdInFmt(command) = &args.sub_command {
      // When formatting via stdin, resolve the config file based on the
      // file path provided to the command. This is done for people who
      // format files in their editor.
      if environment.is_absolute_path(&command.file_name_or_path) {
        if let Some(parent) = PathBuf::from(&command.file_name_or_path).parent() {
          return environment.canonicalize(parent);
        }
      }
    }

    Ok(environment.cwd())
  }

  fn get_default_config_file_in_ancestor_directories(environment: &impl Environment) -> Result<Option<ResolvedConfigPath>> {
    let cwd = environment.cwd().into_path_buf();
    for ancestor_dir in cwd.ancestors() {
      if let Some(ancestor_config_path) = get_config_file_in_dir(&ancestor_dir, environment) {
        return Ok(Some(ResolvedConfigPath {
          resolved_path: ResolvedPath::local(environment.canonicalize(ancestor_config_path)?),
          base_path: environment.canonicalize(ancestor_dir)?,
        }));
      }
    }

    Ok(None)
  }

  fn get_config_file_in_dir(dir: impl AsRef<Path>, environment: &impl Environment) -> Option<PathBuf> {
    if let Some(path) = get_config_file_in_dir_with_name(&dir, DEFAULT_CONFIG_FILE_NAME, environment) {
      Some(path)
    } else if let Some(path) = get_config_file_in_dir_with_name(&dir, HIDDEN_CONFIG_FILE_NAME, environment) {
      Some(path)
    } else if let Some(path) = get_config_file_in_dir_with_name(&dir, OLD_CONFIG_FILE_NAME, environment) {
      environment.log_stderr("WARNING: .dprintrc.json will be deprecated soon. Please rename it to dprint.json");
      Some(path)
    } else {
      None
    }
  }

  fn get_config_file_in_dir_with_name(dir: impl AsRef<Path>, file_name: &str, environment: &impl Environment) -> Option<PathBuf> {
    let config_path = dir.as_ref().join(file_name);
    if environment.path_exists(&config_path) {
      return Some(config_path);
    }
    let config_path = dir.as_ref().join("config").join(file_name);
    if environment.path_exists(&config_path) {
      environment.log_stderr("WARNING: Automatic resolution of the configuration file in the config sub directory will be deprecated soon. Please move the configuration file to the parent directory.");
      return Some(config_path);
    }
    None
  }
}