2024-01-01 14:58:21 -05:00
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
2020-09-05 20:34:02 -04:00
2023-10-20 00:02:08 -04:00
use clap ::builder ::FalseyValueParser ;
2023-03-26 00:06:18 -04:00
use clap ::value_parser ;
2019-06-26 06:02:13 -04:00
use clap ::Arg ;
2023-03-26 00:06:18 -04:00
use clap ::ArgAction ;
2019-06-26 06:02:13 -04:00
use clap ::ArgMatches ;
2022-01-14 11:38:17 -05:00
use clap ::ColorChoice ;
2022-03-27 21:57:56 -04:00
use clap ::Command ;
2022-03-14 14:41:35 -04:00
use clap ::ValueHint ;
2023-08-24 05:21:34 -04:00
use deno_config ::ConfigFlag ;
2023-03-13 21:12:09 -04:00
use deno_core ::resolve_url_or_path ;
2021-01-07 13:06:08 -05:00
use deno_core ::url ::Url ;
2023-06-07 10:09:10 -04:00
use deno_graph ::GraphKind ;
2022-09-29 06:34:16 -04:00
use deno_runtime ::permissions ::parse_sys_kind ;
2021-03-26 12:34:25 -04:00
use log ::debug ;
2019-06-22 12:02:51 -04:00
use log ::Level ;
2022-04-18 15:08:30 -04:00
use std ::env ;
2020-04-03 13:40:11 -04:00
use std ::net ::SocketAddr ;
2021-09-13 16:06:45 -04:00
use std ::num ::NonZeroU32 ;
use std ::num ::NonZeroU8 ;
2021-08-23 06:35:38 -04:00
use std ::num ::NonZeroUsize ;
2023-03-13 21:12:09 -04:00
use std ::path ::Path ;
2020-05-29 11:27:43 -04:00
use std ::path ::PathBuf ;
2020-11-12 17:17:31 -05:00
use std ::str ::FromStr ;
2019-11-26 11:06:32 -05:00
2023-02-23 10:58:10 -05:00
use crate ::util ::fs ::canonicalize_path ;
2023-08-03 07:19:19 -04:00
use super ::flags_net ;
2022-06-27 16:54:09 -04:00
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub struct FileFlags {
2024-01-15 19:15:39 -05:00
pub ignore : Vec < String > ,
pub include : Vec < String > ,
2024-01-08 12:18:42 -05:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub struct BenchFlags {
pub files : FileFlags ,
2022-03-11 17:07:02 -05:00
pub filter : Option < String > ,
2023-02-12 12:40:45 -05:00
pub json : bool ,
2023-03-26 10:55:58 -04:00
pub no_run : bool ,
2023-06-15 13:09:37 -04:00
pub watch : Option < WatchFlags > ,
2022-03-11 17:07:02 -05:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct BundleFlags {
pub source_file : String ,
2024-01-15 19:15:39 -05:00
pub out_file : Option < String > ,
2023-06-15 13:09:37 -04:00
pub watch : Option < WatchFlags > ,
2021-09-03 19:33:35 -04:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct CacheFlags {
pub files : Vec < String > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-04-10 19:12:51 -04:00
pub struct CheckFlags {
pub files : Vec < String > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct CompileFlags {
pub source_file : String ,
pub output : Option < PathBuf > ,
pub args : Vec < String > ,
pub target : Option < String > ,
2023-07-28 11:46:26 -04:00
pub no_terminal : bool ,
2023-03-18 19:43:07 -04:00
pub include : Vec < String > ,
2021-09-03 19:33:35 -04:00
}
2023-07-29 08:06:47 -04:00
impl CompileFlags {
pub fn resolve_target ( & self ) -> String {
self
. target
. clone ( )
. unwrap_or_else ( | | env! ( " TARGET " ) . to_string ( ) )
}
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct CompletionsFlags {
pub buf : Box < [ u8 ] > ,
}
2023-12-18 05:48:45 -05:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2023-12-08 02:54:52 -05:00
pub enum CoverageType {
2023-12-18 05:48:45 -05:00
#[ default ]
2023-12-11 22:42:57 -05:00
Summary ,
2023-12-12 06:53:41 -05:00
Detailed ,
2023-12-08 02:54:52 -05:00
Lcov ,
Html ,
}
2023-12-18 05:48:45 -05:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2021-09-03 19:33:35 -04:00
pub struct CoverageFlags {
2023-01-13 16:56:29 -05:00
pub files : FileFlags ,
2022-02-15 10:33:21 -05:00
pub output : Option < PathBuf > ,
2021-09-03 19:33:35 -04:00
pub include : Vec < String > ,
pub exclude : Vec < String > ,
2023-12-08 02:54:52 -05:00
pub r#type : CoverageType ,
2021-09-03 19:33:35 -04:00
}
2023-01-14 12:39:56 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum DocSourceFileFlag {
Builtin ,
2023-10-30 18:58:57 -04:00
Paths ( Vec < String > ) ,
2023-01-14 12:39:56 -05:00
}
impl Default for DocSourceFileFlag {
fn default ( ) -> Self {
Self ::Builtin
}
}
2023-11-01 11:25:05 -04:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct DocHtmlFlag {
pub name : String ,
pub output : PathBuf ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct DocFlags {
pub private : bool ,
pub json : bool ,
2023-10-31 18:19:42 -04:00
pub lint : bool ,
2023-11-01 11:25:05 -04:00
pub html : Option < DocHtmlFlag > ,
2023-10-30 18:58:57 -04:00
pub source_files : DocSourceFileFlag ,
2021-09-03 19:33:35 -04:00
pub filter : Option < String > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct EvalFlags {
pub print : bool ,
pub code : String ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct FmtFlags {
pub check : bool ,
2023-01-07 15:22:09 -05:00
pub files : FileFlags ,
2021-09-13 16:06:45 -04:00
pub use_tabs : Option < bool > ,
pub line_width : Option < NonZeroU32 > ,
pub indent_width : Option < NonZeroU8 > ,
pub single_quote : Option < bool > ,
pub prose_wrap : Option < String > ,
2023-01-25 15:06:00 -05:00
pub no_semicolons : Option < bool > ,
2023-06-15 13:09:37 -04:00
pub watch : Option < WatchFlags > ,
2021-09-03 19:33:35 -04:00
}
2023-06-14 18:29:19 -04:00
impl FmtFlags {
pub fn is_stdin ( & self ) -> bool {
let args = & self . files . include ;
2024-01-15 19:15:39 -05:00
args . len ( ) = = 1 & & args [ 0 ] = = " - "
2023-06-14 18:29:19 -04:00
}
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-08-19 19:37:05 -04:00
pub struct InitFlags {
pub dir : Option < String > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct InfoFlags {
pub json : bool ,
pub file : Option < String > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct InstallFlags {
pub module_url : String ,
pub args : Vec < String > ,
pub name : Option < String > ,
2023-11-13 09:44:01 -05:00
pub root : Option < String > ,
2021-09-03 19:33:35 -04:00
pub force : bool ,
}
2023-09-15 20:42:09 -04:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct JupyterFlags {
pub install : bool ,
pub kernel : bool ,
pub conn_file : Option < PathBuf > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-30 11:38:07 -04:00
pub struct UninstallFlags {
pub name : String ,
2023-11-13 09:44:01 -05:00
pub root : Option < String > ,
2021-09-30 11:38:07 -04:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct LintFlags {
2023-01-07 15:22:09 -05:00
pub files : FileFlags ,
2021-09-03 19:33:35 -04:00
pub rules : bool ,
2021-11-04 11:12:12 -04:00
pub maybe_rules_tags : Option < Vec < String > > ,
pub maybe_rules_include : Option < Vec < String > > ,
pub maybe_rules_exclude : Option < Vec < String > > ,
2021-09-03 19:33:35 -04:00
pub json : bool ,
2022-09-28 12:47:48 -04:00
pub compact : bool ,
2023-06-15 13:09:37 -04:00
pub watch : Option < WatchFlags > ,
2021-09-03 19:33:35 -04:00
}
2023-06-14 18:29:19 -04:00
impl LintFlags {
pub fn is_stdin ( & self ) -> bool {
let args = & self . files . include ;
2024-01-15 19:15:39 -05:00
args . len ( ) = = 1 & & args [ 0 ] = = " - "
2023-06-14 18:29:19 -04:00
}
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct ReplFlags {
2022-04-20 08:16:37 -04:00
pub eval_files : Option < Vec < String > > ,
2021-09-03 19:33:35 -04:00
pub eval : Option < String > ,
2022-12-07 14:21:18 -05:00
pub is_default_command : bool ,
2021-09-03 19:33:35 -04:00
}
2023-11-14 16:06:00 -05:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2021-09-03 19:33:35 -04:00
pub struct RunFlags {
pub script : String ,
2023-06-15 13:09:37 -04:00
pub watch : Option < WatchFlagsWithPaths > ,
2021-09-03 19:33:35 -04:00
}
2022-08-12 15:21:17 -04:00
impl RunFlags {
2023-12-06 16:36:06 -05:00
#[ cfg(test) ]
pub fn new_default ( script : String ) -> Self {
Self {
script ,
watch : None ,
}
}
2022-08-12 15:21:17 -04:00
pub fn is_stdin ( & self ) -> bool {
self . script = = " - "
}
}
2023-06-15 13:09:37 -04:00
#[ derive(Clone, Default, Debug, Eq, PartialEq) ]
pub struct WatchFlags {
2023-10-30 20:25:58 -04:00
pub hmr : bool ,
2023-06-15 13:09:37 -04:00
pub no_clear_screen : bool ,
}
#[ derive(Clone, Default, Debug, Eq, PartialEq) ]
pub struct WatchFlagsWithPaths {
2023-10-30 20:25:58 -04:00
pub hmr : bool ,
2023-06-15 13:09:37 -04:00
pub paths : Vec < PathBuf > ,
pub no_clear_screen : bool ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-03-10 20:56:14 -05:00
pub struct TaskFlags {
2022-06-08 17:30:16 -04:00
pub cwd : Option < String > ,
2023-02-22 22:45:35 -05:00
pub task : Option < String > ,
2022-03-10 20:56:14 -05:00
}
2023-08-02 12:38:10 -04:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub enum TestReporterConfig {
#[ default ]
Pretty ,
Dot ,
2023-08-02 22:05:34 -04:00
Junit ,
2023-08-25 19:19:23 -04:00
Tap ,
2023-08-02 12:38:10 -04:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct TestFlags {
pub doc : bool ,
pub no_run : bool ,
2023-06-15 13:09:37 -04:00
pub coverage_dir : Option < String > ,
2021-09-03 19:33:35 -04:00
pub fail_fast : Option < NonZeroUsize > ,
2023-01-07 15:22:09 -05:00
pub files : FileFlags ,
2021-09-03 19:33:35 -04:00
pub allow_none : bool ,
pub filter : Option < String > ,
pub shuffle : Option < u64 > ,
2023-01-07 15:22:09 -05:00
pub concurrent_jobs : Option < NonZeroUsize > ,
2022-02-25 10:14:46 -05:00
pub trace_ops : bool ,
2023-06-15 13:09:37 -04:00
pub watch : Option < WatchFlags > ,
2023-08-02 12:38:10 -04:00
pub reporter : TestReporterConfig ,
2023-08-02 22:05:34 -04:00
pub junit_path : Option < String > ,
2021-09-03 19:33:35 -04:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 19:33:35 -04:00
pub struct UpgradeFlags {
pub dry_run : bool ,
pub force : bool ,
pub canary : bool ,
pub version : Option < String > ,
pub output : Option < PathBuf > ,
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-02-16 13:14:19 -05:00
pub struct VendorFlags {
pub specifiers : Vec < String > ,
pub output_path : Option < PathBuf > ,
pub force : bool ,
}
2023-11-23 18:38:07 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct PublishFlags {
pub token : Option < String > ,
2024-01-11 16:17:03 -05:00
pub dry_run : bool ,
2023-11-23 18:38:07 -05:00
}
2023-01-07 15:22:09 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2019-11-26 11:06:32 -05:00
pub enum DenoSubcommand {
2022-03-11 17:07:02 -05:00
Bench ( BenchFlags ) ,
2021-09-03 19:33:35 -04:00
Bundle ( BundleFlags ) ,
Cache ( CacheFlags ) ,
2022-04-10 19:12:51 -04:00
Check ( CheckFlags ) ,
2021-09-03 19:33:35 -04:00
Compile ( CompileFlags ) ,
Completions ( CompletionsFlags ) ,
Coverage ( CoverageFlags ) ,
Doc ( DocFlags ) ,
Eval ( EvalFlags ) ,
Fmt ( FmtFlags ) ,
2022-08-19 19:37:05 -04:00
Init ( InitFlags ) ,
2021-09-03 19:33:35 -04:00
Info ( InfoFlags ) ,
Install ( InstallFlags ) ,
2023-09-15 20:42:09 -04:00
Jupyter ( JupyterFlags ) ,
2021-09-30 11:38:07 -04:00
Uninstall ( UninstallFlags ) ,
2021-06-22 21:48:01 -04:00
Lsp ,
2021-09-03 19:33:35 -04:00
Lint ( LintFlags ) ,
Repl ( ReplFlags ) ,
Run ( RunFlags ) ,
2022-03-10 20:56:14 -05:00
Task ( TaskFlags ) ,
2021-09-03 19:33:35 -04:00
Test ( TestFlags ) ,
2019-11-26 11:06:32 -05:00
Types ,
2021-09-03 19:33:35 -04:00
Upgrade ( UpgradeFlags ) ,
2022-02-16 13:14:19 -05:00
Vendor ( VendorFlags ) ,
2023-11-23 18:38:07 -05:00
Publish ( PublishFlags ) ,
2019-11-26 11:06:32 -05:00
}
2023-11-11 12:01:48 -05:00
impl DenoSubcommand {
pub fn is_run ( & self ) -> bool {
matches! ( self , Self ::Run ( _ ) )
}
2023-11-14 16:06:00 -05:00
2023-11-24 22:46:16 -05:00
// Returns `true` if the subcommand depends on testing infrastructure.
pub fn needs_test ( & self ) -> bool {
matches! (
self ,
Self ::Test ( _ )
| Self ::Jupyter ( _ )
| Self ::Repl ( _ )
| Self ::Bench ( _ )
| Self ::Lsp
)
2023-11-14 16:06:00 -05:00
}
2023-11-11 12:01:48 -05:00
}
2019-11-26 11:06:32 -05:00
impl Default for DenoSubcommand {
fn default ( ) -> DenoSubcommand {
2022-04-20 08:16:37 -04:00
DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
eval : None ,
2022-12-07 14:21:18 -05:00
is_default_command : true ,
2022-04-20 08:16:37 -04:00
} )
2019-11-26 11:06:32 -05:00
}
2018-08-17 16:34:30 -04:00
}
2022-09-19 04:25:03 -04:00
#[ derive(Debug, Clone, Copy, Eq, PartialEq) ]
2022-04-10 19:12:51 -04:00
pub enum TypeCheckMode {
2022-06-18 12:11:15 -04:00
/// Type-check all modules.
2021-11-29 17:23:30 -05:00
All ,
2022-06-18 12:11:15 -04:00
/// Skip type-checking of all modules. The default value for "deno run" and
2022-06-13 17:13:16 -04:00
/// several other subcommands.
2021-11-29 17:23:30 -05:00
None ,
2022-06-18 12:11:15 -04:00
/// Only type-check local modules. The default value for "deno test" and
2022-06-13 17:13:16 -04:00
/// several other subcommands.
2021-11-29 17:23:30 -05:00
Local ,
}
2023-06-07 10:09:10 -04:00
impl TypeCheckMode {
/// Gets if type checking will occur under this mode.
pub fn is_true ( & self ) -> bool {
match self {
Self ::None = > false ,
Self ::Local | Self ::All = > true ,
}
}
/// Gets the corresponding module `GraphKind` that should be created
/// for the current `TypeCheckMode`.
pub fn as_graph_kind ( & self ) -> GraphKind {
match self . is_true ( ) {
true = > GraphKind ::All ,
false = > GraphKind ::CodeOnly ,
}
}
}
2022-04-10 19:12:51 -04:00
impl Default for TypeCheckMode {
2021-11-29 17:23:30 -05:00
fn default ( ) -> Self {
2022-06-13 17:13:16 -04:00
Self ::None
2022-04-10 19:12:51 -04:00
}
}
2023-01-17 19:18:24 -05:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum CaData {
/// The string is a file path
File ( String ) ,
/// This variant is not exposed as an option in the CLI, it is used internally
/// for standalone binaries.
Bytes ( Vec < u8 > ) ,
}
2022-09-19 04:25:03 -04:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2020-02-26 05:52:15 -05:00
pub struct Flags {
2019-12-03 17:23:10 -05:00
/// Vector of CLI arguments - these are user script arguments, all Deno
/// specific flags are removed.
2019-11-26 11:06:32 -05:00
pub argv : Vec < String > ,
pub subcommand : DenoSubcommand ,
2022-01-10 09:22:03 -05:00
pub allow_all : bool ,
2021-04-13 07:25:21 -04:00
pub allow_env : Option < Vec < String > > ,
2023-08-03 07:19:19 -04:00
pub deny_env : Option < Vec < String > > ,
2019-05-23 12:28:29 -04:00
pub allow_hrtime : bool ,
2023-08-03 07:19:19 -04:00
pub deny_hrtime : bool ,
2020-12-29 13:34:35 -05:00
pub allow_net : Option < Vec < String > > ,
2023-08-03 07:19:19 -04:00
pub deny_net : Option < Vec < String > > ,
2021-10-13 13:04:44 -04:00
pub allow_ffi : Option < Vec < PathBuf > > ,
2023-08-03 07:19:19 -04:00
pub deny_ffi : Option < Vec < PathBuf > > ,
2020-12-29 13:34:35 -05:00
pub allow_read : Option < Vec < PathBuf > > ,
2023-08-03 07:19:19 -04:00
pub deny_read : Option < Vec < PathBuf > > ,
2021-04-09 18:12:00 -04:00
pub allow_run : Option < Vec < String > > ,
2023-08-03 07:19:19 -04:00
pub deny_run : Option < Vec < String > > ,
2022-09-28 08:46:50 -04:00
pub allow_sys : Option < Vec < String > > ,
2023-08-03 07:19:19 -04:00
pub deny_sys : Option < Vec < String > > ,
2020-12-29 13:34:35 -05:00
pub allow_write : Option < Vec < PathBuf > > ,
2023-08-03 07:19:19 -04:00
pub deny_write : Option < Vec < PathBuf > > ,
2021-08-07 08:49:38 -04:00
pub ca_stores : Option < Vec < String > > ,
2023-01-17 19:18:24 -05:00
pub ca_data : Option < CaData > ,
2021-07-23 10:31:16 -04:00
pub cache_blocklist : Vec < String > ,
2021-07-27 17:25:09 -04:00
/// This is not exposed as an option in the CLI, it is used internally when
/// the language server is configured with an explicit cache option.
pub cache_path : Option < PathBuf > ,
2019-12-03 17:48:53 -05:00
pub cached_only : bool ,
2022-04-10 19:12:51 -04:00
pub type_check_mode : TypeCheckMode ,
2022-05-13 11:40:50 -04:00
pub config_flag : ConfigFlag ,
2023-02-20 13:14:06 -05:00
pub node_modules_dir : Option < bool > ,
2023-08-06 21:56:56 -04:00
pub vendor : Option < bool > ,
2023-11-05 16:27:36 -05:00
pub enable_op_summary_metrics : bool ,
2021-07-23 10:31:16 -04:00
pub enable_testing_features : bool ,
2023-03-22 10:15:53 -04:00
pub ext : Option < String > ,
2020-10-21 07:12:01 -04:00
pub ignore : Vec < PathBuf > ,
2020-04-30 11:23:40 -04:00
pub import_map_path : Option < String > ,
2023-11-01 11:21:13 -04:00
pub env_file : Option < String > ,
2020-04-03 13:40:11 -04:00
pub inspect_brk : Option < SocketAddr > ,
2022-12-12 09:33:30 -05:00
pub inspect_wait : Option < SocketAddr > ,
2021-07-23 10:31:16 -04:00
pub inspect : Option < SocketAddr > ,
pub location : Option < Url > ,
2019-11-03 10:39:27 -05:00
pub lock_write : bool ,
2021-07-23 10:31:16 -04:00
pub lock : Option < PathBuf > ,
2020-04-30 11:23:40 -04:00
pub log_level : Option < Level > ,
pub no_remote : bool ,
2022-11-03 11:42:56 -04:00
pub no_lock : bool ,
2022-09-07 09:33:51 -04:00
pub no_npm : bool ,
2022-02-12 22:13:21 -05:00
pub no_prompt : bool ,
2020-04-30 11:23:40 -04:00
pub reload : bool ,
pub seed : Option < u64 > ,
2023-11-10 12:41:24 -05:00
pub strace_ops : Option < Vec < String > > ,
2020-04-30 11:23:40 -04:00
pub unstable : bool ,
2023-11-01 19:04:54 -04:00
pub unstable_bare_node_builtins : bool ,
2023-10-25 14:39:00 -04:00
pub unstable_byonm : bool ,
2023-12-06 19:03:18 -05:00
pub unstable_sloppy_imports : bool ,
2023-11-16 20:28:38 -05:00
pub unstable_workspaces : bool ,
2023-11-01 18:15:08 -04:00
pub unstable_features : Vec < String > ,
2021-08-10 07:19:45 -04:00
pub unsafely_ignore_certificate_errors : Option < Vec < String > > ,
2020-12-06 12:19:21 -05:00
pub v8_flags : Vec < String > ,
2018-11-15 12:56:17 -05:00
}
2020-06-13 13:09:39 -04:00
fn join_paths ( allowlist : & [ PathBuf ] , d : & str ) -> String {
allowlist
2020-02-11 04:29:36 -05:00
. iter ( )
. map ( | path | path . to_str ( ) . unwrap ( ) . to_string ( ) )
. collect ::< Vec < String > > ( )
. join ( d )
}
2020-02-26 05:52:15 -05:00
impl Flags {
2020-01-30 18:42:39 -05:00
/// Return list of permission arguments that are equivalent
/// to the ones used to create `self`.
pub fn to_permission_args ( & self ) -> Vec < String > {
let mut args = vec! [ ] ;
2022-01-10 09:22:03 -05:00
if self . allow_all {
args . push ( " --allow-all " . to_string ( ) ) ;
return args ;
}
2020-12-29 13:34:35 -05:00
match & self . allow_read {
Some ( read_allowlist ) if read_allowlist . is_empty ( ) = > {
args . push ( " --allow-read " . to_string ( ) ) ;
}
Some ( read_allowlist ) = > {
let s = format! ( " --allow-read= {} " , join_paths ( read_allowlist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 18:42:39 -05:00
}
2023-08-03 07:19:19 -04:00
match & self . deny_read {
Some ( read_denylist ) if read_denylist . is_empty ( ) = > {
args . push ( " --deny-read " . to_string ( ) ) ;
}
Some ( read_denylist ) = > {
let s = format! ( " --deny-read= {} " , join_paths ( read_denylist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2020-12-29 13:34:35 -05:00
match & self . allow_write {
Some ( write_allowlist ) if write_allowlist . is_empty ( ) = > {
args . push ( " --allow-write " . to_string ( ) ) ;
}
Some ( write_allowlist ) = > {
let s = format! ( " --allow-write= {} " , join_paths ( write_allowlist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 18:42:39 -05:00
}
2023-08-03 07:19:19 -04:00
match & self . deny_write {
Some ( write_denylist ) if write_denylist . is_empty ( ) = > {
args . push ( " --deny-write " . to_string ( ) ) ;
}
Some ( write_denylist ) = > {
let s = format! ( " --deny-write= {} " , join_paths ( write_denylist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2020-12-29 13:34:35 -05:00
match & self . allow_net {
Some ( net_allowlist ) if net_allowlist . is_empty ( ) = > {
args . push ( " --allow-net " . to_string ( ) ) ;
}
Some ( net_allowlist ) = > {
let s = format! ( " --allow-net= {} " , net_allowlist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 18:42:39 -05:00
}
2023-08-03 07:19:19 -04:00
match & self . deny_net {
Some ( net_denylist ) if net_denylist . is_empty ( ) = > {
args . push ( " --deny-net " . to_string ( ) ) ;
}
Some ( net_denylist ) = > {
let s = format! ( " --deny-net= {} " , net_denylist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2021-08-10 07:19:45 -04:00
match & self . unsafely_ignore_certificate_errors {
2021-08-09 10:53:21 -04:00
Some ( ic_allowlist ) if ic_allowlist . is_empty ( ) = > {
2021-08-10 08:19:42 -04:00
args . push ( " --unsafely-ignore-certificate-errors " . to_string ( ) ) ;
2021-08-09 10:53:21 -04:00
}
Some ( ic_allowlist ) = > {
let s = format! (
2021-08-10 08:19:42 -04:00
" --unsafely-ignore-certificate-errors={} " ,
2021-08-09 10:53:21 -04:00
ic_allowlist . join ( " , " )
) ;
args . push ( s ) ;
}
_ = > { }
}
2021-04-13 07:25:21 -04:00
match & self . allow_env {
Some ( env_allowlist ) if env_allowlist . is_empty ( ) = > {
args . push ( " --allow-env " . to_string ( ) ) ;
}
Some ( env_allowlist ) = > {
let s = format! ( " --allow-env= {} " , env_allowlist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 18:42:39 -05:00
}
2023-08-03 07:19:19 -04:00
match & self . deny_env {
Some ( env_denylist ) if env_denylist . is_empty ( ) = > {
args . push ( " --deny-env " . to_string ( ) ) ;
}
Some ( env_denylist ) = > {
let s = format! ( " --deny-env= {} " , env_denylist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2021-04-09 18:12:00 -04:00
match & self . allow_run {
Some ( run_allowlist ) if run_allowlist . is_empty ( ) = > {
args . push ( " --allow-run " . to_string ( ) ) ;
}
Some ( run_allowlist ) = > {
let s = format! ( " --allow-run= {} " , run_allowlist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 18:42:39 -05:00
}
2023-08-03 07:19:19 -04:00
match & self . deny_run {
Some ( run_denylist ) if run_denylist . is_empty ( ) = > {
args . push ( " --deny-run " . to_string ( ) ) ;
}
Some ( run_denylist ) = > {
let s = format! ( " --deny-run= {} " , run_denylist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2022-09-28 08:46:50 -04:00
match & self . allow_sys {
Some ( sys_allowlist ) if sys_allowlist . is_empty ( ) = > {
args . push ( " --allow-sys " . to_string ( ) ) ;
}
Some ( sys_allowlist ) = > {
let s = format! ( " --allow-sys= {} " , sys_allowlist . join ( " , " ) ) ;
args . push ( s )
}
_ = > { }
}
2023-08-03 07:19:19 -04:00
match & self . deny_sys {
Some ( sys_denylist ) if sys_denylist . is_empty ( ) = > {
args . push ( " --deny-sys " . to_string ( ) ) ;
}
Some ( sys_denylist ) = > {
let s = format! ( " --deny-sys= {} " , sys_denylist . join ( " , " ) ) ;
args . push ( s )
}
_ = > { }
}
2021-08-06 17:28:10 -04:00
match & self . allow_ffi {
Some ( ffi_allowlist ) if ffi_allowlist . is_empty ( ) = > {
args . push ( " --allow-ffi " . to_string ( ) ) ;
}
Some ( ffi_allowlist ) = > {
2021-10-13 13:04:44 -04:00
let s = format! ( " --allow-ffi= {} " , join_paths ( ffi_allowlist , " , " ) ) ;
2021-08-06 17:28:10 -04:00
args . push ( s ) ;
}
_ = > { }
2020-01-30 18:42:39 -05:00
}
2023-08-03 07:19:19 -04:00
match & self . deny_ffi {
Some ( ffi_denylist ) if ffi_denylist . is_empty ( ) = > {
args . push ( " --deny-ffi " . to_string ( ) ) ;
}
Some ( ffi_denylist ) = > {
let s = format! ( " --deny-ffi= {} " , join_paths ( ffi_denylist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2020-01-30 18:42:39 -05:00
if self . allow_hrtime {
args . push ( " --allow-hrtime " . to_string ( ) ) ;
}
2023-08-03 07:19:19 -04:00
if self . deny_hrtime {
args . push ( " --deny-hrtime " . to_string ( ) ) ;
}
2020-01-30 18:42:39 -05:00
args
}
2022-01-17 20:10:17 -05:00
/// Extract path arguments for config search paths.
2022-02-25 00:39:18 -05:00
/// If it returns Some(vec), the config should be discovered
2023-03-13 21:12:09 -04:00
/// from the passed `current_dir` after trying to discover from each entry in
/// the returned vector.
2022-02-25 00:39:18 -05:00
/// If it returns None, the config file shouldn't be discovered at all.
2023-03-13 21:12:09 -04:00
pub fn config_path_args ( & self , current_dir : & Path ) -> Option < Vec < PathBuf > > {
2022-01-17 20:10:17 -05:00
use DenoSubcommand ::* ;
2023-01-14 23:06:46 -05:00
match & self . subcommand {
2024-01-15 19:15:39 -05:00
Fmt ( FmtFlags { files , .. } ) = > {
Some ( files . include . iter ( ) . map ( | p | current_dir . join ( p ) ) . collect ( ) )
}
Lint ( LintFlags { files , .. } ) = > {
Some ( files . include . iter ( ) . map ( | p | current_dir . join ( p ) ) . collect ( ) )
}
2023-06-15 13:09:37 -04:00
Run ( RunFlags { script , .. } ) = > {
2023-03-13 21:12:09 -04:00
if let Ok ( module_specifier ) = resolve_url_or_path ( script , current_dir ) {
2023-01-14 23:06:46 -05:00
if module_specifier . scheme ( ) = = " file "
| | module_specifier . scheme ( ) = = " npm "
{
if let Ok ( p ) = module_specifier . to_file_path ( ) {
Some ( vec! [ p ] )
} else {
Some ( vec! [ ] )
}
2022-02-25 00:39:18 -05:00
} else {
2023-01-14 23:06:46 -05:00
// When the entrypoint doesn't have file: scheme (it's the remote
// script), then we don't auto discover config file.
None
2022-02-25 00:39:18 -05:00
}
2022-01-17 20:10:17 -05:00
} else {
2023-01-14 23:06:46 -05:00
Some ( vec! [ ] )
2022-01-17 20:10:17 -05:00
}
}
2023-02-23 10:58:10 -05:00
Task ( TaskFlags {
cwd : Some ( path ) , ..
} ) = > {
2024-01-15 19:15:39 -05:00
// todo(dsherret): Why is this canonicalized? Document why.
2023-02-23 10:58:10 -05:00
// attempt to resolve the config file from the task subcommand's
// `--cwd` when specified
match canonicalize_path ( & PathBuf ::from ( path ) ) {
Ok ( path ) = > Some ( vec! [ path ] ) ,
Err ( _ ) = > Some ( vec! [ ] ) ,
}
}
2023-01-14 23:06:46 -05:00
_ = > Some ( vec! [ ] ) ,
2022-01-17 20:10:17 -05:00
}
}
2020-01-30 18:42:39 -05:00
2023-02-20 13:14:06 -05:00
/// Extract path argument for `package.json` search paths.
/// If it returns Some(path), the `package.json` should be discovered
/// from the `path` dir.
/// If it returns None, the `package.json` file shouldn't be discovered at
/// all.
2023-03-13 21:12:09 -04:00
pub fn package_json_search_dir ( & self , current_dir : & Path ) -> Option < PathBuf > {
2023-02-20 13:14:06 -05:00
use DenoSubcommand ::* ;
2023-02-22 22:45:35 -05:00
match & self . subcommand {
2023-06-15 13:09:37 -04:00
Run ( RunFlags { script , .. } ) = > {
2023-03-13 21:12:09 -04:00
let module_specifier = resolve_url_or_path ( script , current_dir ) . ok ( ) ? ;
2023-02-20 13:14:06 -05:00
if module_specifier . scheme ( ) = = " file " {
let p = module_specifier
. to_file_path ( )
. unwrap ( )
. parent ( ) ?
. to_owned ( ) ;
2023-02-22 22:45:35 -05:00
Some ( p )
2023-02-20 13:14:06 -05:00
} else if module_specifier . scheme ( ) = = " npm " {
2023-02-22 22:45:35 -05:00
Some ( std ::env ::current_dir ( ) . unwrap ( ) )
} else {
None
2023-02-20 13:14:06 -05:00
}
}
2023-02-22 22:45:35 -05:00
Task ( TaskFlags { cwd : Some ( cwd ) , .. } ) = > {
2023-03-13 21:12:09 -04:00
resolve_url_or_path ( cwd , current_dir )
2023-02-22 22:45:35 -05:00
. ok ( ) ?
. to_file_path ( )
. ok ( )
}
2023-02-23 10:58:10 -05:00
Task ( _ ) | Check ( _ ) | Coverage ( _ ) | Cache ( _ ) | Info ( _ ) | Eval ( _ )
2023-05-10 20:06:59 -04:00
| Test ( _ ) | Bench ( _ ) | Repl ( _ ) | Compile ( _ ) = > {
std ::env ::current_dir ( ) . ok ( )
}
Bundle ( _ ) | Completions ( _ ) | Doc ( _ ) | Fmt ( _ ) | Init ( _ ) | Install ( _ )
2023-09-15 20:42:09 -04:00
| Uninstall ( _ ) | Jupyter ( _ ) | Lsp | Lint ( _ ) | Types | Upgrade ( _ )
2023-11-23 18:38:07 -05:00
| Vendor ( _ ) | Publish ( _ ) = > None ,
2023-02-20 13:14:06 -05:00
}
}
2022-11-23 22:00:31 -05:00
pub fn has_permission ( & self ) -> bool {
self . allow_all
| | self . allow_hrtime
2023-08-03 07:19:19 -04:00
| | self . deny_hrtime
2022-11-23 22:00:31 -05:00
| | self . allow_env . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_env . is_some ( )
2022-11-23 22:00:31 -05:00
| | self . allow_ffi . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_ffi . is_some ( )
2022-11-23 22:00:31 -05:00
| | self . allow_net . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_net . is_some ( )
2022-11-23 22:00:31 -05:00
| | self . allow_read . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_read . is_some ( )
2022-11-23 22:00:31 -05:00
| | self . allow_run . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_run . is_some ( )
2022-11-23 22:00:31 -05:00
| | self . allow_sys . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_sys . is_some ( )
2022-11-23 22:00:31 -05:00
| | self . allow_write . is_some ( )
2023-08-03 07:19:19 -04:00
| | self . deny_write . is_some ( )
2022-11-23 22:00:31 -05:00
}
pub fn has_permission_in_argv ( & self ) -> bool {
self . argv . iter ( ) . any ( | arg | {
arg = = " --allow-all "
| | arg = = " --allow-hrtime "
2023-08-03 07:19:19 -04:00
| | arg = = " --deny-hrtime "
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-env " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-env " )
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-ffi " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-ffi " )
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-net " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-net " )
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-read " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-read " )
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-run " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-run " )
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-sys " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-sys " )
2022-11-23 22:00:31 -05:00
| | arg . starts_with ( " --allow-write " )
2023-08-03 07:19:19 -04:00
| | arg . starts_with ( " --deny-write " )
2022-11-23 22:00:31 -05:00
} )
}
2020-12-29 13:34:35 -05:00
}
2021-02-15 21:50:27 -05:00
static ENV_VARIABLES_HELP : & str = r #" ENVIRONMENT VARIABLES:
DENO_AUTH_TOKENS A semi - colon separated list of bearer tokens and
hostnames to use when fetching remote modules from
private repositories
( e . g . " abcde12345@deno.land;54321edcba@github.com " )
2022-04-11 01:01:02 -04:00
DENO_TLS_CA_STORE Comma - separated list of order dependent certificate
stores . Possible values : " system " , " mozilla " .
Defaults to " mozilla " .
2021-02-15 21:50:27 -05:00
DENO_CERT Load certificate authority from PEM encoded file
2020-06-15 12:29:39 -04:00
DENO_DIR Set the cache directory
2020-04-16 18:15:42 -04:00
DENO_INSTALL_ROOT Set deno install ' s output directory
( defaults to $HOME / . deno / bin )
2023-03-16 12:22:24 -04:00
DENO_REPL_HISTORY Set REPL history file path
History file is disabled when the value is empty
( defaults to $DENO_DIR / deno_history . txt )
2023-02-24 14:23:07 -05:00
DENO_NO_PACKAGE_JSON Disables auto - resolution of package . json
2022-04-18 15:08:30 -04:00
DENO_NO_PROMPT Set to disable permission prompts on access
( alternative to passing - - no - prompt on invocation )
2022-10-22 14:31:25 -04:00
DENO_NO_UPDATE_CHECK Set to disable checking if a newer Deno version is
2022-10-20 10:15:21 -04:00
available
2023-01-24 23:03:03 -05:00
DENO_V8_FLAGS Set V8 command line options
2023-12-08 19:19:16 -05:00
DENO_WEBGPU_TRACE Directory to use for wgpu traces
2022-07-20 17:36:54 -04:00
DENO_JOBS Number of parallel workers used for the - - parallel
flag with the test subcommand . Defaults to number
of available CPUs .
2020-04-16 18:15:42 -04:00
HTTP_PROXY Proxy address for HTTP requests
( module downloads , fetch )
2020-06-08 12:06:06 -04:00
HTTPS_PROXY Proxy address for HTTPS requests
2020-08-15 09:48:29 -04:00
( module downloads , fetch )
2022-12-07 16:10:50 -05:00
NPM_CONFIG_REGISTRY URL to use for the npm registry .
2021-02-15 21:50:27 -05:00
NO_COLOR Set to disable color
2020-08-15 09:48:29 -04:00
NO_PROXY Comma - separated list of hosts which do not use a proxy
2021-02-15 21:50:27 -05:00
( module downloads , fetch ) " #;
2019-06-05 13:44:46 -04:00
2023-03-27 12:28:41 -04:00
static DENO_HELP : & str = concat! (
" A modern JavaScript and TypeScript runtime
2019-05-06 10:48:19 -04:00
2023-03-27 12:28:41 -04:00
Docs : https ://deno.land/manual@v",
env! ( " CARGO_PKG_VERSION " ) ,
"
2020-03-10 19:23:08 -04:00
Modules : https ://deno.land/std/ https://deno.land/x/
2019-05-23 14:57:44 -04:00
Bugs : https ://github.com/denoland/deno/issues
2020-05-04 07:03:30 -04:00
To start the REPL :
2021-04-18 09:12:55 -04:00
2019-05-23 14:57:44 -04:00
deno
2019-11-26 11:06:32 -05:00
To execute a script :
2021-04-18 09:12:55 -04:00
2023-11-20 17:59:13 -05:00
deno run https ://examples.deno.land/hello-world.ts
2019-05-23 14:57:44 -04:00
2020-03-10 19:23:08 -04:00
To evaluate code in the shell :
2021-04-18 09:12:55 -04:00
2020-03-10 19:23:08 -04:00
deno eval \ " console.log(30933 + 404) \"
2023-03-27 12:28:41 -04:00
"
) ;
2019-05-23 14:57:44 -04:00
2019-11-26 11:06:32 -05:00
/// Main entry point for parsing deno's command line flags.
2023-03-26 00:06:18 -04:00
pub fn flags_from_vec ( args : Vec < String > ) -> clap ::error ::Result < Flags > {
let mut app = clap_root ( ) ;
let mut matches = app . try_get_matches_from_mut ( & args ) ? ;
2019-11-26 11:06:32 -05:00
2020-02-26 05:52:15 -05:00
let mut flags = Flags ::default ( ) ;
2019-11-26 11:06:32 -05:00
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " unstable " ) {
2020-09-20 07:45:00 -04:00
flags . unstable = true ;
}
2023-11-25 11:41:21 -05:00
for ( name , _ , _ ) in crate ::UNSTABLE_GRANULAR_FLAGS {
if matches . get_flag ( & format! ( " unstable- {} " , name ) ) {
flags . unstable_features . push ( name . to_string ( ) ) ;
}
2023-11-01 18:15:08 -04:00
}
2023-01-14 23:06:46 -05:00
2023-11-01 19:04:54 -04:00
flags . unstable_bare_node_builtins =
2023-10-25 14:39:00 -04:00
matches . get_flag ( " unstable-bare-node-builtins " ) ;
flags . unstable_byonm = matches . get_flag ( " unstable-byonm " ) ;
2023-12-06 19:03:18 -05:00
flags . unstable_sloppy_imports = matches . get_flag ( " unstable-sloppy-imports " ) ;
2023-10-20 00:02:08 -04:00
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " quiet " ) {
2020-03-10 08:26:17 -04:00
flags . log_level = Some ( Level ::Error ) ;
2023-03-26 00:06:18 -04:00
} else if let Some ( log_level ) = matches . get_one ::< String > ( " log-level " ) {
flags . log_level = match log_level . as_str ( ) {
2023-09-09 14:03:19 -04:00
" trace " = > Some ( Level ::Trace ) ,
2023-03-26 00:06:18 -04:00
" debug " = > Some ( Level ::Debug ) ,
" info " = > Some ( Level ::Info ) ,
_ = > unreachable! ( ) ,
} ;
2020-03-10 08:26:17 -04:00
}
2019-11-26 11:06:32 -05:00
2023-03-26 00:06:18 -04:00
if let Some ( ( subcommand , mut m ) ) = matches . remove_subcommand ( ) {
match subcommand . as_str ( ) {
" bench " = > bench_parse ( & mut flags , & mut m ) ,
" bundle " = > bundle_parse ( & mut flags , & mut m ) ,
" cache " = > cache_parse ( & mut flags , & mut m ) ,
" check " = > check_parse ( & mut flags , & mut m ) ,
" compile " = > compile_parse ( & mut flags , & mut m ) ,
" completions " = > completions_parse ( & mut flags , & mut m , app ) ,
" coverage " = > coverage_parse ( & mut flags , & mut m ) ,
" doc " = > doc_parse ( & mut flags , & mut m ) ,
" eval " = > eval_parse ( & mut flags , & mut m ) ,
" fmt " = > fmt_parse ( & mut flags , & mut m ) ,
" init " = > init_parse ( & mut flags , & mut m ) ,
" info " = > info_parse ( & mut flags , & mut m ) ,
" install " = > install_parse ( & mut flags , & mut m ) ,
2023-09-15 20:42:09 -04:00
" jupyter " = > jupyter_parse ( & mut flags , & mut m ) ,
2023-03-26 00:06:18 -04:00
" lint " = > lint_parse ( & mut flags , & mut m ) ,
" lsp " = > lsp_parse ( & mut flags , & mut m ) ,
" repl " = > repl_parse ( & mut flags , & mut m ) ,
2023-08-12 22:04:17 -04:00
" run " = > run_parse ( & mut flags , & mut m , app ) ? ,
2023-03-26 00:06:18 -04:00
" task " = > task_parse ( & mut flags , & mut m ) ,
" test " = > test_parse ( & mut flags , & mut m ) ,
" types " = > types_parse ( & mut flags , & mut m ) ,
" uninstall " = > uninstall_parse ( & mut flags , & mut m ) ,
" upgrade " = > upgrade_parse ( & mut flags , & mut m ) ,
" vendor " = > vendor_parse ( & mut flags , & mut m ) ,
2024-01-08 15:07:36 -05:00
" publish " = > publish_parse ( & mut flags , & mut m ) ,
2023-03-26 00:06:18 -04:00
_ = > unreachable! ( ) ,
}
} else {
handle_repl_flags (
2022-04-20 08:16:37 -04:00
& mut flags ,
ReplFlags {
eval_files : None ,
eval : None ,
2022-12-07 14:21:18 -05:00
is_default_command : true ,
2022-04-20 08:16:37 -04:00
} ,
2023-03-26 00:06:18 -04:00
)
2019-11-26 11:06:32 -05:00
}
Ok ( flags )
}
2022-01-14 11:38:17 -05:00
fn handle_repl_flags ( flags : & mut Flags , repl_flags : ReplFlags ) {
2022-12-07 14:21:18 -05:00
// If user runs just `deno` binary we enter REPL and allow all permissions.
if repl_flags . is_default_command {
flags . allow_net = Some ( vec! [ ] ) ;
flags . allow_env = Some ( vec! [ ] ) ;
flags . allow_run = Some ( vec! [ ] ) ;
flags . allow_read = Some ( vec! [ ] ) ;
flags . allow_sys = Some ( vec! [ ] ) ;
flags . allow_write = Some ( vec! [ ] ) ;
flags . allow_ffi = Some ( vec! [ ] ) ;
flags . allow_hrtime = true ;
}
2022-01-14 11:38:17 -05:00
flags . subcommand = DenoSubcommand ::Repl ( repl_flags ) ;
}
2023-03-26 00:06:18 -04:00
fn clap_root ( ) -> Command {
2023-03-27 12:28:41 -04:00
let long_version = format! (
" {} ({}, {}) \n v8 {} \n typescript {} " ,
crate ::version ::deno ( ) ,
if crate ::version ::is_canary ( ) {
" canary "
} else {
env! ( " PROFILE " )
} ,
env! ( " TARGET " ) ,
deno_core ::v8_version ( ) ,
crate ::version ::TYPESCRIPT
) ;
2023-11-01 18:15:08 -04:00
let mut cmd = Command ::new ( " deno " )
2019-11-26 11:06:32 -05:00
. bin_name ( " deno " )
2022-01-14 11:38:17 -05:00
. color ( ColorChoice ::Never )
2022-04-11 01:01:02 -04:00
. max_term_width ( 80 )
2023-03-26 00:06:18 -04:00
. version ( crate ::version ::deno ( ) )
2023-03-27 12:28:41 -04:00
. long_version ( long_version )
2023-12-06 09:22:30 -05:00
// cause --unstable flags to display at the bottom of the help text
. next_display_order ( 1000 )
2020-09-20 07:45:00 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " unstable " )
2020-09-20 07:45:00 -04:00
. long ( " unstable " )
. help ( " Enable unstable features and APIs " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2020-09-20 07:45:00 -04:00
. global ( true ) ,
)
2023-10-20 00:02:08 -04:00
. arg (
Arg ::new ( " unstable-bare-node-builtins " )
. long ( " unstable-bare-node-builtins " )
. help ( " Enable unstable bare node builtins feature " )
. env ( " DENO_UNSTABLE_BARE_NODE_BUILTINS " )
. value_parser ( FalseyValueParser ::new ( ) )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
)
2023-10-25 14:39:00 -04:00
. arg (
Arg ::new ( " unstable-byonm " )
. long ( " unstable-byonm " )
. help ( " Enable unstable 'bring your own node_modules' feature " )
. env ( " DENO_UNSTABLE_BYONM " )
. value_parser ( FalseyValueParser ::new ( ) )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
2023-11-16 20:28:38 -05:00
)
2023-12-06 19:03:18 -05:00
. arg (
Arg ::new ( " unstable-sloppy-imports " )
. long ( " unstable-sloppy-imports " )
. help (
" Enable unstable resolving of specifiers by extension probing, .js to .ts, and directory probing. " ,
)
. env ( " DENO_UNSTABLE_SLOPPY_IMPORTS " )
. value_parser ( FalseyValueParser ::new ( ) )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
2023-11-01 18:15:08 -04:00
) ;
for ( flag_name , help , _ ) in crate ::UNSTABLE_GRANULAR_FLAGS {
cmd = cmd . arg (
Arg ::new ( format! ( " unstable- {} " , flag_name ) )
. long ( format! ( " unstable- {} " , flag_name ) )
. help ( help )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
) ;
}
cmd
2023-12-06 09:22:30 -05:00
// reset the display order after the unstable flags
. next_display_order ( 0 )
2019-04-06 18:13:06 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " log-level " )
. short ( 'L' )
2019-06-22 12:02:51 -04:00
. long ( " log-level " )
. help ( " Set log level " )
2022-04-11 01:01:02 -04:00
. hide ( true )
2023-09-09 14:03:19 -04:00
. value_parser ( [ " trace " , " debug " , " info " ] )
2019-05-03 17:15:16 -04:00
. global ( true ) ,
2019-07-31 11:02:20 -04:00
)
2020-03-10 08:26:17 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " quiet " )
. short ( 'q' )
2020-03-10 08:26:17 -04:00
. long ( " quiet " )
. help ( " Suppress diagnostic output " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2020-03-10 08:26:17 -04:00
. global ( true ) ,
)
2019-11-26 11:06:32 -05:00
. subcommand ( run_subcommand ( ) )
2023-06-12 07:54:04 -04:00
. defer ( | cmd | {
cmd
. subcommand ( bench_subcommand ( ) )
. subcommand ( bundle_subcommand ( ) )
. subcommand ( cache_subcommand ( ) )
. subcommand ( check_subcommand ( ) )
. subcommand ( compile_subcommand ( ) )
. subcommand ( completions_subcommand ( ) )
. subcommand ( coverage_subcommand ( ) )
. subcommand ( doc_subcommand ( ) )
. subcommand ( eval_subcommand ( ) )
. subcommand ( fmt_subcommand ( ) )
. subcommand ( init_subcommand ( ) )
. subcommand ( info_subcommand ( ) )
. subcommand ( install_subcommand ( ) )
2023-09-15 20:42:09 -04:00
. subcommand ( jupyter_subcommand ( ) )
2023-06-12 07:54:04 -04:00
. subcommand ( uninstall_subcommand ( ) )
. subcommand ( lsp_subcommand ( ) )
. subcommand ( lint_subcommand ( ) )
2023-11-23 18:38:07 -05:00
. subcommand ( publish_subcommand ( ) )
2023-06-12 07:54:04 -04:00
. subcommand ( repl_subcommand ( ) )
. subcommand ( task_subcommand ( ) )
. subcommand ( test_subcommand ( ) )
. subcommand ( types_subcommand ( ) )
. subcommand ( upgrade_subcommand ( ) )
. subcommand ( vendor_subcommand ( ) )
} )
2023-03-27 12:28:41 -04:00
. long_about ( DENO_HELP )
2019-11-26 11:06:32 -05:00
. after_help ( ENV_VARIABLES_HELP )
}
2019-11-13 10:35:56 -05:00
2023-03-26 00:06:18 -04:00
fn bench_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " bench " )
. about ( " Run benchmarks " )
. long_about (
" Run benchmarks using Deno's built-in bench tool.
2022-03-11 17:07:02 -05:00
2023-03-27 12:28:41 -04:00
Evaluate the given modules , run all benches declared with ' Deno . bench ( ) '
2022-04-11 01:01:02 -04:00
and report results to standard output :
2022-03-11 17:07:02 -05:00
deno bench src / fetch_bench . ts src / signal_bench . ts
2023-03-27 12:28:41 -04:00
Directory arguments are expanded to all contained files matching the
2022-08-15 15:16:23 -04:00
glob { * _ , * . , } bench . { js , mjs , ts , mts , jsx , tsx } :
2022-03-11 17:07:02 -05:00
deno bench src / " ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
runtime_args ( cmd , true , false )
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " json " )
. long ( " json " )
. action ( ArgAction ::SetTrue )
. help ( " UNSTABLE: Output benchmark result in JSON format " ) ,
)
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
2024-01-15 19:15:39 -05:00
. help ( " Ignore files " ) ,
2023-06-27 20:57:20 -04:00
)
. arg (
Arg ::new ( " filter " )
. long ( " filter " )
. allow_hyphen_values ( true )
. help (
" Run benchmarks with this string or pattern in the bench name " ,
) ,
)
. arg (
Arg ::new ( " files " )
. help ( " List of file names to run " )
. num_args ( .. )
. action ( ArgAction ::Append ) ,
)
. arg (
Arg ::new ( " no-run " )
. long ( " no-run " )
. help ( " Cache bench modules, but don't run benchmarks " )
. action ( ArgAction ::SetTrue ) ,
)
. arg ( watch_arg ( false ) )
. arg ( no_clear_screen_arg ( ) )
. arg ( script_arg ( ) . last ( true ) )
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2023-06-27 20:57:20 -04:00
} )
2022-03-11 17:07:02 -05:00
}
2023-03-26 00:06:18 -04:00
fn bundle_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " bundle " )
. about ( " Bundle module and dependencies into single file " )
. long_about (
" Output a single JavaScript file with all dependencies.
2021-04-18 09:12:55 -04:00
2023-12-01 21:20:06 -05:00
deno bundle https ://deno.land/std/http/file_server.ts file_server.bundle.js
2021-04-16 09:28:41 -04:00
If no output file is given , the output is written to standard output :
2021-04-18 09:12:55 -04:00
2023-12-01 21:20:06 -05:00
deno bundle https ://deno.land/std/http/file_server.ts",
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
compile_args ( cmd )
. hide ( true )
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " source_file " )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2024-01-15 19:15:39 -05:00
. arg ( Arg ::new ( " out_file " ) . value_hint ( ValueHint ::FilePath ) )
2023-06-27 20:57:20 -04:00
. arg ( watch_arg ( false ) )
. arg ( no_clear_screen_arg ( ) )
. arg ( executable_ext_arg ( ) )
} )
2019-11-26 11:06:32 -05:00
}
2019-06-11 14:38:19 -04:00
2023-03-26 00:06:18 -04:00
fn cache_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " cache " )
. about ( " Cache the dependencies " )
. long_about (
" Cache and compile remote dependencies recursively.
2021-01-19 12:39:35 -05:00
2023-03-27 12:28:41 -04:00
Download and compile a module with all of its static dependencies and save
2022-04-11 01:01:02 -04:00
them in the local cache , without running any code :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno cache https ://deno.land/std/http/file_server.ts
2023-03-27 12:28:41 -04:00
Future runs of this module will trigger no downloads or compilation unless
2021-04-16 09:28:41 -04:00
- - reload is specified . " ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
compile_args ( cmd ) . arg ( check_arg ( false ) ) . arg (
Arg ::new ( " file " )
. num_args ( 1 .. )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
2023-06-12 07:54:04 -04:00
)
2023-06-27 20:57:20 -04:00
} )
2019-11-26 11:06:32 -05:00
}
2019-05-01 19:15:37 -04:00
2023-03-26 00:06:18 -04:00
fn check_subcommand ( ) -> Command {
2023-06-12 07:54:04 -04:00
Command ::new ( " check " )
2023-06-27 20:57:20 -04:00
. about ( " Type-check the dependencies " )
. long_about (
" Download and type-check without execution.
deno check https ://deno.land/std/http/file_server.ts
Unless - - reload is specified , this command will not re - download already cached dependencies . " ,
)
2023-06-12 07:54:04 -04:00
. defer ( | cmd | compile_args_without_check_args ( cmd ) . arg (
2022-12-07 13:33:26 -05:00
Arg ::new ( " all " )
. long ( " all " )
. help ( " Type-check all code, including remote modules and npm packages " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-12-07 13:33:26 -05:00
. conflicts_with ( " no-remote " )
2022-04-10 19:12:51 -04:00
)
2023-06-12 07:54:04 -04:00
. arg (
// past alias for --all
Arg ::new ( " remote " )
. long ( " remote " )
. help ( " Type-check all modules, including remote " )
. action ( ArgAction ::SetTrue )
. conflicts_with ( " no-remote " )
. hide ( true )
2022-12-07 13:33:26 -05:00
)
2023-06-12 07:54:04 -04:00
. arg (
Arg ::new ( " file " )
. num_args ( 1 .. )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2023-06-27 20:57:20 -04:00
)
2022-04-10 19:12:51 -04:00
}
2023-03-26 00:06:18 -04:00
fn compile_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " compile " )
2023-10-27 21:54:52 -04:00
. about ( " Compile the script into a self contained executable " )
2023-06-27 20:57:20 -04:00
. long_about (
2023-10-27 21:54:52 -04:00
" Compiles the given script into a self contained executable.
2023-06-27 20:57:20 -04:00
deno compile - A https ://deno.land/std/http/file_server.ts
2023-12-01 21:20:06 -05:00
deno compile - - output file_server https ://deno.land/std/http/file_server.ts
2023-06-27 20:57:20 -04:00
Any flags passed which affect runtime behavior , such as ' - - unstable ' ,
' - - allow - * ' , ' - - v8 - flags ' , etc . are encoded into the output executable and
used at runtime as if they were passed to a similar ' deno run ' command .
The executable name is inferred by default : Attempt to take the file stem of
the URL path . The above example would become ' file_server ' . If the file stem
is something generic like ' main ' , ' mod ' , ' index ' or ' cli ' , and the path has no
parent , take the file name of the parent path . Otherwise settle with the
generic name . If the resulting name has an ' @ .. . ' suffix , strip it .
Cross - compiling to different target architectures is supported using the
` - - target ` flag . On the first invocation with deno will download proper
binary and cache it in $DENO_DIR . The aarch64 - apple - darwin target is not
supported in canary .
" ,
)
. defer ( | cmd | {
runtime_args ( cmd , true , false )
2023-06-12 07:54:04 -04:00
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " include " )
. long ( " include " )
2023-10-27 21:54:52 -04:00
. help ( " Additional module to include in the module graph " )
2023-06-12 07:54:04 -04:00
. long_help (
" Includes an additional module in the compiled executable's module
2023-03-27 12:28:41 -04:00
graph . Use this flag if a dynamically imported module or a web worker main
module fails to load in the executable . This flag can be passed multiple
2023-03-18 19:43:07 -04:00
times , to include multiple additional modules . " ,
2023-06-12 07:54:04 -04:00
)
. action ( ArgAction ::Append )
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. short ( 'o' )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-06-12 07:54:04 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. help ( " Output file (defaults to $PWD/<inferred-name>) " )
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " target " )
. long ( " target " )
. help ( " Target OS architecture " )
. value_parser ( [
" x86_64-unknown-linux-gnu " ,
" x86_64-pc-windows-msvc " ,
" x86_64-apple-darwin " ,
" aarch64-apple-darwin " ,
] ) ,
)
2023-07-28 11:46:26 -04:00
. arg (
Arg ::new ( " no-terminal " )
. long ( " no-terminal " )
. help ( " Hide terminal on Windows " )
. action ( ArgAction ::SetTrue ) ,
)
2023-06-12 07:54:04 -04:00
. arg ( executable_ext_arg ( ) )
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2023-09-08 13:14:59 -04:00
. arg ( script_arg ( ) . required ( true ) . trailing_var_arg ( true ) )
2023-06-27 20:57:20 -04:00
} )
2019-11-26 11:06:32 -05:00
}
2019-05-01 19:15:37 -04:00
2023-03-26 00:06:18 -04:00
fn completions_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " completions " )
. about ( " Generate shell completions " )
. long_about (
" Output shell completion script to standard output.
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno completions bash > / usr / local / etc / bash_completion . d / deno . bash
source / usr / local / etc / bash_completion . d / deno . bash " ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
cmd . disable_help_subcommand ( true ) . arg (
Arg ::new ( " shell " )
. value_parser ( [ " bash " , " fish " , " powershell " , " zsh " , " fig " ] )
. required ( true ) ,
2023-06-12 07:54:04 -04:00
)
2023-06-27 20:57:20 -04:00
} )
2020-11-30 14:35:12 -05:00
}
2023-03-26 00:06:18 -04:00
fn coverage_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " coverage " )
. about ( " Print coverage reports " )
. long_about (
" Print coverage reports from coverage profiles.
2020-02-17 11:59:51 -05:00
2021-04-16 09:28:41 -04:00
Collect a coverage profile with deno test :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno test - - coverage = cov_profile
2020-02-04 14:24:33 -05:00
2021-04-16 09:28:41 -04:00
Print a report to stdout :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno coverage cov_profile
2020-02-04 14:24:33 -05:00
2021-04-16 09:28:41 -04:00
Include urls that start with the file schema :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno coverage - - include = \ " ^file: \" cov_profile
2020-11-22 15:45:44 -05:00
2021-04-16 09:28:41 -04:00
Exclude urls ending with test . ts and test . js :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno coverage - - exclude = \ " test \\ .(ts|js) \" cov_profile
2019-05-23 14:57:44 -04:00
2023-03-27 12:28:41 -04:00
Include urls that start with the file schema and exclude files ending with
test . ts and test . js , for an url to match it must match the include pattern and
2022-04-11 01:01:02 -04:00
not match the exclude pattern :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno coverage - - include = \ " ^file: \" --exclude= \" test \\ .(ts|js) \" cov_profile
2020-02-04 14:24:33 -05:00
2021-04-16 09:28:41 -04:00
Write a report using the lcov format :
2021-04-18 09:12:55 -04:00
2022-02-15 10:33:21 -05:00
deno coverage - - lcov - - output = cov . lcov cov_profile /
2021-04-16 09:28:41 -04:00
Generate html reports from lcov :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
genhtml - o html_cov cov . lcov
" ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
cmd
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Ignore coverage files " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " include " )
. long ( " include " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. value_name ( " regex " )
. require_equals ( true )
. default_value ( r "^file:" )
. help ( " Include source files in the report " ) ,
)
. arg (
Arg ::new ( " exclude " )
. long ( " exclude " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. value_name ( " regex " )
. require_equals ( true )
. default_value ( r "test\.(js|mjs|ts|jsx|tsx)$" )
. help ( " Exclude source files from the report " ) ,
)
. arg (
Arg ::new ( " lcov " )
. long ( " lcov " )
. help ( " Output coverage report in lcov format " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " output " )
. requires ( " lcov " )
. long ( " output " )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-06-27 20:57:20 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. help ( " Output file (defaults to stdout) for lcov " )
. long_help (
" Exports the coverage report in lcov format to the given file.
2023-03-27 12:28:41 -04:00
Filename should be passed along with '=' For example ' - - output = foo . lcov '
2022-04-11 01:01:02 -04:00
If no - - output arg is specified then the report is written to stdout . " ,
2023-06-27 20:57:20 -04:00
)
. require_equals ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2023-12-08 02:54:52 -05:00
. arg (
Arg ::new ( " html " )
. long ( " html " )
. help (
" Output coverage report in HTML format in the given directory " ,
)
. action ( ArgAction ::SetTrue ) ,
)
2023-12-11 22:42:57 -05:00
. arg (
2023-12-12 06:53:41 -05:00
Arg ::new ( " detailed " )
. long ( " detailed " )
. help ( " Output coverage report in detailed format in the terminal. " )
2023-12-11 22:42:57 -05:00
. action ( ArgAction ::SetTrue ) ,
)
2023-06-27 20:57:20 -04:00
. arg (
Arg ::new ( " files " )
2023-12-18 05:48:45 -05:00
. num_args ( 0 .. )
2023-06-27 20:57:20 -04:00
. action ( ArgAction ::Append )
. value_hint ( ValueHint ::AnyPath ) ,
)
} )
2019-11-26 11:06:32 -05:00
}
2019-08-11 20:43:01 -04:00
2023-03-26 00:06:18 -04:00
fn doc_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " doc " )
. about ( " Show documentation for a module " )
. long_about (
" Show documentation for a module.
2019-05-01 19:15:37 -04:00
2021-04-16 09:28:41 -04:00
Output documentation to standard output :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno doc . / path / to / module . ts
2019-05-01 19:15:37 -04:00
2023-11-01 11:25:05 -04:00
Output documentation in HTML format :
deno doc - - html - - name = \ " My library \" ./path/to/module.ts
deno doc - - html - - name = \ " My library \" ./main.ts ./dev.ts
deno doc - - html - - name = \ " My library \" --output=./documentation/ ./path/to/module.ts
2021-04-16 09:28:41 -04:00
Output private documentation to standard output :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno doc - - private . / path / to / module . ts
2019-05-01 19:15:37 -04:00
2021-04-16 09:28:41 -04:00
Output documentation in JSON format :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno doc - - json . / path / to / module . ts
2021-02-24 09:27:51 -05:00
2023-10-31 18:19:42 -04:00
Lint a module for documentation diagnostics :
deno doc - - lint . / path / to / module . ts
2021-04-16 09:28:41 -04:00
Target a specific symbol :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno doc . / path / to / module . ts MyClass . someField
2019-05-06 10:48:19 -04:00
2021-04-16 09:28:41 -04:00
Show documentation for runtime built - ins :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno doc
deno doc - - builtin Deno . Listener " ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
cmd
. arg ( import_map_arg ( ) )
. arg ( reload_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( no_lock_arg ( ) )
. arg ( no_npm_arg ( ) )
. arg ( no_remote_arg ( ) )
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " Output documentation in JSON format " )
. action ( ArgAction ::SetTrue ) ,
)
2023-11-01 11:25:05 -04:00
. arg (
Arg ::new ( " html " )
. long ( " html " )
. help ( " Output documentation in HTML format " )
. action ( ArgAction ::SetTrue )
. conflicts_with ( " json " )
)
. arg (
Arg ::new ( " name " )
. long ( " name " )
. help ( " The name that will be displayed in the docs " )
. action ( ArgAction ::Set )
. required_if_eq ( " html " , " true " )
. require_equals ( true )
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " Directory for HTML documentation output " )
. action ( ArgAction ::Set )
. require_equals ( true )
. value_hint ( ValueHint ::DirPath )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-11-01 11:25:05 -04:00
. value_parser ( value_parser! ( PathBuf ) )
)
2023-06-27 20:57:20 -04:00
. arg (
Arg ::new ( " private " )
. long ( " private " )
. help ( " Output private documentation " )
. action ( ArgAction ::SetTrue ) ,
)
2023-10-30 18:58:57 -04:00
. arg (
Arg ::new ( " filter " )
. long ( " filter " )
. help ( " Dot separated path to symbol " )
. required ( false )
2023-10-31 18:19:42 -04:00
. conflicts_with ( " json " )
2023-11-01 11:25:05 -04:00
. conflicts_with ( " lint " )
. conflicts_with ( " html " ) ,
2023-10-31 18:19:42 -04:00
)
. arg (
Arg ::new ( " lint " )
. long ( " lint " )
. help ( " Output documentation diagnostics. " )
. action ( ArgAction ::SetTrue ) ,
2023-10-30 18:58:57 -04:00
)
2023-06-27 20:57:20 -04:00
// TODO(nayeemrmn): Make `--builtin` a proper option. Blocked by
// https://github.com/clap-rs/clap/issues/1794. Currently `--builtin` is
// just a possible value of `source_file` so leading hyphens must be
// enabled.
. allow_hyphen_values ( true )
. arg (
2023-10-30 18:58:57 -04:00
Arg ::new ( " source_file " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
2023-11-03 13:06:18 -04:00
. value_hint ( ValueHint ::FilePath )
. required_if_eq_any ( [ ( " html " , " true " ) , ( " lint " , " true " ) ] ) ,
2023-06-27 20:57:20 -04:00
)
} )
2020-09-18 13:09:11 -04:00
}
2023-03-26 00:06:18 -04:00
fn eval_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " eval " )
. about ( " Eval script " )
. long_about (
" Evaluate JavaScript from the command line.
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno eval \ " console.log('hello world') \"
2019-11-26 11:06:32 -05:00
2021-04-16 09:28:41 -04:00
To evaluate as TypeScript :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno eval - - ext = ts \ " const v: string = 'hello'; console.log(v) \"
2019-11-26 11:06:32 -05:00
2021-04-16 09:28:41 -04:00
This command has implicit access to all permissions ( - - allow - all ) . " ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
runtime_args ( cmd , false , true )
. arg ( check_arg ( false ) )
. arg (
// TODO(@satyarohith): remove this argument in 2.0.
Arg ::new ( " ts " )
. conflicts_with ( " ext " )
. long ( " ts " )
. short ( 'T' )
. help ( " deprecated: Treat eval input as TypeScript " )
. action ( ArgAction ::SetTrue )
. hide ( true ) ,
)
. arg ( executable_ext_arg ( ) )
. arg (
Arg ::new ( " print " )
. long ( " print " )
. short ( 'p' )
. help ( " print result to stdout " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " code_arg " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. help ( " Code arg " )
. value_name ( " CODE_ARG " )
. required ( true ) ,
)
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2023-06-27 20:57:20 -04:00
} )
2019-11-26 11:06:32 -05:00
}
2023-03-26 00:06:18 -04:00
fn fmt_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " fmt " )
. about ( " Format source files " )
. long_about (
" Auto-format JavaScript, TypeScript, Markdown, and JSON files.
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno fmt
deno fmt myfile1 . ts myfile2 . ts
deno fmt - - check
2020-02-09 05:19:05 -05:00
2020-03-10 19:23:08 -04:00
Format stdin and write to stdout :
2021-04-18 09:12:55 -04:00
2020-05-04 15:17:15 -04:00
cat file . ts | deno fmt -
Ignore formatting code by preceding it with an ignore comment :
2021-04-18 09:12:55 -04:00
2020-05-04 15:17:15 -04:00
// deno-fmt-ignore
Ignore formatting a file by adding an ignore comment at the top of the file :
2021-04-18 09:12:55 -04:00
2020-05-04 15:17:15 -04:00
// deno-fmt-ignore-file",
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
cmd
. arg ( config_arg ( ) )
. arg ( no_config_arg ( ) )
. arg (
Arg ::new ( " check " )
. long ( " check " )
. help ( " Check if the source files are formatted " )
. num_args ( 0 ) ,
)
. arg (
Arg ::new ( " ext " )
. long ( " ext " )
. help ( " Set content type of the supplied file " )
// prefer using ts for formatting instead of js because ts works in more scenarios
. default_value ( " ts " )
2023-11-27 10:32:12 -05:00
. value_parser ( [
" ts " , " tsx " , " js " , " jsx " , " md " , " json " , " jsonc " , " ipynb " ,
] ) ,
2023-06-27 20:57:20 -04:00
)
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Ignore formatting particular source files " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " files " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. required ( false )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg ( watch_arg ( false ) )
. arg ( no_clear_screen_arg ( ) )
. arg (
Arg ::new ( " use-tabs " )
. long ( " use-tabs " )
. alias ( " options-use-tabs " )
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
. help (
" Use tabs instead of spaces for indentation. Defaults to false. " ,
) ,
)
. arg (
Arg ::new ( " line-width " )
. long ( " line-width " )
. alias ( " options-line-width " )
. help ( " Define maximum line width. Defaults to 80. " )
. value_parser ( value_parser! ( NonZeroU32 ) ) ,
)
. arg (
Arg ::new ( " indent-width " )
. long ( " indent-width " )
. alias ( " options-indent-width " )
. help ( " Define indentation width. Defaults to 2. " )
. value_parser ( value_parser! ( NonZeroU8 ) ) ,
)
. arg (
Arg ::new ( " single-quote " )
. long ( " single-quote " )
. alias ( " options-single-quote " )
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
. help ( " Use single quotes. Defaults to false. " ) ,
)
. arg (
Arg ::new ( " prose-wrap " )
. long ( " prose-wrap " )
. alias ( " options-prose-wrap " )
. value_parser ( [ " always " , " never " , " preserve " ] )
. help ( " Define how prose should be wrapped. Defaults to always. " ) ,
)
. arg (
Arg ::new ( " no-semicolons " )
. long ( " no-semicolons " )
. alias ( " options-no-semicolons " )
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
2023-12-01 11:26:06 -05:00
. help (
" Don't use semicolons except where necessary. Defaults to false. " ,
) ,
2023-06-27 20:57:20 -04:00
)
} )
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-03-26 00:06:18 -04:00
fn init_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " init " )
. about ( " Initialize a new project " )
. defer ( | cmd | {
cmd . arg (
Arg ::new ( " dir " )
. required ( false )
. value_hint ( ValueHint ::DirPath ) ,
)
} )
2022-08-19 19:37:05 -04:00
}
2023-03-26 00:06:18 -04:00
fn info_subcommand ( ) -> Command {
2022-03-27 21:57:56 -04:00
Command ::new ( " info " )
2023-06-27 20:57:20 -04:00
. about ( " Show info about cache or info related to source file " )
2023-06-12 07:54:04 -04:00
. long_about (
" Information about a module or the cache directories.
2021-04-16 09:28:41 -04:00
Get information about a module :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno info https ://deno.land/std/http/file_server.ts
The following information is shown :
local : Local path of the file .
type : JavaScript , TypeScript , or JSON .
2021-09-13 07:50:04 -04:00
emit : Local path of compiled source code . ( TypeScript only . )
dependencies : Dependency tree of the source file .
2021-04-16 09:28:41 -04:00
Without any additional arguments , ' deno info ' shows :
DENO_DIR : Directory containing Deno - managed files .
Remote modules cache : Subdirectory containing downloaded remote modules .
TypeScript compiler cache : Subdirectory containing TS compiler output . " ,
2023-06-12 07:54:04 -04:00
)
2023-06-27 20:57:20 -04:00
. defer ( | cmd | cmd
2023-06-12 07:54:04 -04:00
. arg ( Arg ::new ( " file " ) . required ( false ) . value_hint ( ValueHint ::FilePath ) )
. arg ( reload_arg ( ) . requires ( " file " ) )
. arg ( ca_file_arg ( ) )
. arg (
location_arg ( )
. conflicts_with ( " file " )
. help ( " Show files used for origin bound APIs like the Web Storage API when running a script with '--location=<HREF>' " )
)
. arg ( no_check_arg ( ) . hide ( true ) ) // TODO(lucacasonato): remove for 2.0
. arg ( no_config_arg ( ) )
. arg ( no_remote_arg ( ) )
. arg ( no_npm_arg ( ) )
. arg ( no_lock_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( config_arg ( ) )
. arg ( import_map_arg ( ) )
. arg ( node_modules_dir_arg ( ) )
2023-08-06 21:56:56 -04:00
. arg ( vendor_arg ( ) )
2023-06-12 07:54:04 -04:00
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " UNSTABLE: Outputs the information in JSON format " )
. action ( ArgAction ::SetTrue ) ,
) )
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-03-26 00:06:18 -04:00
fn install_subcommand ( ) -> Command {
2023-06-12 07:54:04 -04:00
Command ::new ( " install " )
2023-06-27 20:57:20 -04:00
. about ( " Install script as an executable " )
. long_about (
2023-06-12 07:54:04 -04:00
" Installs a script as an executable in the installation root's bin directory.
2021-04-18 09:12:55 -04:00
2020-05-01 15:33:11 -04:00
deno install - - allow - net - - allow - read https ://deno.land/std/http/file_server.ts
2023-12-01 21:20:06 -05:00
deno install https ://examples.deno.land/color-logging.ts
2020-05-01 15:33:11 -04:00
To change the executable name , use - n / - - name :
2021-04-18 09:12:55 -04:00
2020-05-01 15:33:11 -04:00
deno install - - allow - net - - allow - read - n serve https ://deno.land/std/http/file_server.ts
The executable name is inferred by default :
- Attempt to take the file stem of the URL path . The above example would
become ' file_server ' .
- If the file stem is something generic like ' main ' , ' mod ' , ' index ' or ' cli ' ,
and the path has no parent , take the file name of the parent path . Otherwise
settle with the generic name .
2020-08-27 16:55:58 -04:00
- If the resulting name has an ' @ .. . ' suffix , strip it .
2019-05-03 17:15:16 -04:00
2020-04-16 18:15:42 -04:00
To change the installation root , use - - root :
2021-04-18 09:12:55 -04:00
2020-05-01 15:33:11 -04:00
deno install - - allow - net - - allow - read - - root / usr / local https ://deno.land/std/http/file_server.ts
2020-04-16 18:15:42 -04:00
The installation root is determined , in order of precedence :
- - - root option
- DENO_INSTALL_ROOT environment variable
- $HOME / . deno
2023-06-27 20:57:20 -04:00
These must be added to the path manually if required . " )
. defer ( | cmd | runtime_args ( cmd , true , true ) . arg ( Arg ::new ( " cmd " ) . required ( true ) . num_args ( 1 .. ) . value_hint ( ValueHint ::FilePath ) )
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " name " )
. long ( " name " )
. short ( 'n' )
. help ( " Executable file name " )
. required ( false ) )
2023-06-12 07:54:04 -04:00
. arg (
Arg ::new ( " root " )
. long ( " root " )
. help ( " Installation root " )
. value_hint ( ValueHint ::DirPath ) )
2023-06-27 20:57:20 -04:00
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help ( " Forcefully overwrite existing installation " )
. action ( ArgAction ::SetTrue ) )
)
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2023-06-27 20:57:20 -04:00
}
2023-09-15 20:42:09 -04:00
fn jupyter_subcommand ( ) -> Command {
Command ::new ( " jupyter " )
. arg (
Arg ::new ( " install " )
. long ( " install " )
. help ( " Installs kernelspec, requires 'jupyter' command to be available. " )
. conflicts_with ( " kernel " )
. action ( ArgAction ::SetTrue )
)
. arg (
Arg ::new ( " kernel " )
. long ( " kernel " )
. help ( " Start the kernel " )
. conflicts_with ( " install " )
. requires ( " conn " )
. action ( ArgAction ::SetTrue )
)
. arg (
Arg ::new ( " conn " )
. long ( " conn " )
. help ( " Path to JSON file describing connection parameters, provided by Jupyter " )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-09-15 20:42:09 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. value_hint ( ValueHint ::FilePath )
. conflicts_with ( " install " ) )
. about ( " Deno kernel for Jupyter notebooks " )
}
2023-06-27 20:57:20 -04:00
fn uninstall_subcommand ( ) -> Command {
Command ::new ( " uninstall " )
2023-06-12 07:54:04 -04:00
. about ( " Uninstall a script previously installed with deno install " )
. long_about (
" Uninstalls an executable script in the installation root's bin directory.
2021-09-30 11:38:07 -04:00
deno uninstall serve
To change the installation root , use - - root :
deno uninstall - - root / usr / local serve
The installation root is determined , in order of precedence :
- - - root option
- DENO_INSTALL_ROOT environment variable
2023-06-27 20:57:20 -04:00
- $HOME / . deno " )
. defer ( | cmd | cmd . arg ( Arg ::new ( " name " ) . required ( true ) )
. arg (
Arg ::new ( " root " )
. long ( " root " )
. help ( " Installation root " )
. value_hint ( ValueHint ::DirPath ) )
)
2021-09-30 11:38:07 -04:00
}
2023-03-27 12:28:41 -04:00
static LSP_HELP : & str = concat! (
" The 'deno lsp' subcommand provides a way for code editors and IDEs to
2021-04-16 09:28:41 -04:00
interact with Deno using the Language Server Protocol . Usually humans do not
use this subcommand directly . For example , ' deno lsp ' can provide IDEs with
go - to - definition support and automatic code formatting .
How to connect various editors and IDEs to ' deno lsp ' :
2023-03-27 12:28:41 -04:00
https ://deno.land/manual@v",
env! ( " CARGO_PKG_VERSION " ) ,
" /getting_started/setup_your_environment#editors-and-ides " ,
) ;
2022-05-09 14:16:34 -04:00
2023-03-26 00:06:18 -04:00
fn lsp_subcommand ( ) -> Command {
2022-05-09 14:16:34 -04:00
Command ::new ( " lsp " )
2023-06-27 20:57:20 -04:00
. about ( " Start the language server " )
. long_about ( LSP_HELP )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn lint_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " lint " )
. about ( " Lint source files " )
. long_about (
" Lint JavaScript/TypeScript source code.
2021-04-18 09:12:55 -04:00
2021-04-27 06:44:36 -04:00
deno lint
deno lint myfile1 . ts myfile2 . js
2021-04-16 09:28:41 -04:00
Print result as JSON :
2021-04-18 09:12:55 -04:00
2021-04-27 06:44:36 -04:00
deno lint - - json
2021-04-16 09:28:41 -04:00
Read from stdin :
2021-04-18 09:12:55 -04:00
2021-04-27 06:44:36 -04:00
cat file . ts | deno lint -
cat file . ts | deno lint - - json -
2021-04-16 09:28:41 -04:00
List available rules :
2021-04-18 09:12:55 -04:00
2021-04-27 06:44:36 -04:00
deno lint - - rules
2021-04-16 09:28:41 -04:00
Ignore diagnostics on the next line by preceding it with an ignore comment and
rule name :
2021-04-18 09:12:55 -04:00
// deno-lint-ignore no-explicit-any
2021-04-16 09:28:41 -04:00
// deno-lint-ignore require-await no-empty
Names of rules to ignore must be specified after ignore comment .
Ignore linting a file by adding an ignore comment at the top of the file :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
// deno-lint-ignore-file
" ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
cmd
. arg (
Arg ::new ( " rules " )
. long ( " rules " )
. help ( " List available rules " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " rules-tags " )
. long ( " rules-tags " )
. require_equals ( true )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. use_value_delimiter ( true )
. help ( " Use set of rules with a tag " ) ,
)
. arg (
Arg ::new ( " rules-include " )
. long ( " rules-include " )
. require_equals ( true )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. conflicts_with ( " rules " )
. help ( " Include lint rules " ) ,
)
. arg (
Arg ::new ( " rules-exclude " )
. long ( " rules-exclude " )
. require_equals ( true )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. conflicts_with ( " rules " )
. help ( " Exclude lint rules " ) ,
)
. arg ( no_config_arg ( ) )
. arg ( config_arg ( ) )
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Ignore linting particular source files " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " Output lint result in JSON format " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " compact " )
. long ( " compact " )
. help ( " Output lint result in compact format " )
. action ( ArgAction ::SetTrue )
. conflicts_with ( " json " ) ,
)
. arg (
Arg ::new ( " files " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. required ( false )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg ( watch_arg ( false ) )
. arg ( no_clear_screen_arg ( ) )
} )
2021-04-16 09:28:41 -04:00
}
2019-05-16 10:39:19 -04:00
2023-03-26 00:06:18 -04:00
fn repl_subcommand ( ) -> Command {
2023-06-12 07:54:04 -04:00
Command ::new ( " repl " )
2023-06-27 20:57:20 -04:00
. about ( " Read Eval Print Loop " )
. defer ( | cmd | runtime_args ( cmd , true , true )
2023-06-12 07:54:04 -04:00
. arg ( check_arg ( false ) )
. arg (
Arg ::new ( " eval-file " )
. long ( " eval-file " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Evaluates the provided file(s) as scripts when the REPL starts. Accepts file paths and URLs. " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " eval " )
. long ( " eval " )
. help ( " Evaluates the provided code when the REPL starts. " )
. value_name ( " code " ) ,
) )
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2019-11-26 11:06:32 -05:00
}
2023-03-26 00:06:18 -04:00
fn run_subcommand ( ) -> Command {
2022-03-27 21:57:56 -04:00
runtime_args ( Command ::new ( " run " ) , true , true )
2023-04-12 21:42:28 -04:00
. arg ( check_arg ( false ) )
2023-10-06 17:33:14 -04:00
. arg ( watch_arg ( true ) )
2023-10-30 20:25:58 -04:00
. arg ( hmr_arg ( true ) )
2022-01-31 11:39:39 -05:00
. arg ( no_clear_screen_arg ( ) )
2023-03-22 10:15:53 -04:00
. arg ( executable_ext_arg ( ) )
2023-03-26 00:06:18 -04:00
. arg (
script_arg ( )
. required_unless_present ( " v8-flags " )
. trailing_var_arg ( true ) ,
)
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2021-04-18 09:12:55 -04:00
. about ( " Run a JavaScript or TypeScript program " )
2019-11-26 11:06:32 -05:00
. long_about (
2021-04-18 09:12:55 -04:00
" Run a JavaScript or TypeScript program
2020-02-28 09:17:56 -05:00
2021-04-16 09:28:41 -04:00
By default all programs are run in sandbox without access to disk , network or
ability to spawn subprocesses .
2021-04-18 09:12:55 -04:00
2023-11-20 17:59:13 -05:00
deno run https ://examples.deno.land/hello-world.ts
2020-03-10 19:23:08 -04:00
2021-04-16 09:28:41 -04:00
Grant all permissions :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno run - A https ://deno.land/std/http/file_server.ts
Grant permission to read from disk and listen to network :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno run - - allow - read - - allow - net https ://deno.land/std/http/file_server.ts
Grant permission to read allow - listed files from disk :
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno run - - allow - read = / etc https ://deno.land/std/http/file_server.ts
2022-04-11 01:01:02 -04:00
Specifying the filename '-' to read the file from stdin .
2021-04-18 09:12:55 -04:00
2023-11-20 17:59:13 -05:00
curl https ://examples.deno.land/hello-world.ts | deno run -",
2020-02-28 09:17:56 -05:00
)
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn task_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " task " )
. about ( " Run a task defined in the configuration file " )
. long_about (
" Run a task defined in the configuration file
2022-03-10 20:56:14 -05:00
deno task build " ,
2023-06-27 20:57:20 -04:00
)
. defer ( | cmd | {
cmd
. allow_external_subcommands ( true )
. subcommand_value_name ( " TASK " )
. arg ( config_arg ( ) )
. arg (
Arg ::new ( " cwd " )
. long ( " cwd " )
. value_name ( " DIR " )
. help ( " Specify the directory to run the task in " )
. value_hint ( ValueHint ::DirPath ) ,
)
} )
2022-03-10 20:56:14 -05:00
}
2023-03-26 00:06:18 -04:00
fn test_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " test " )
. about ( " Run tests " )
. long_about (
" Run tests using Deno's built-in test runner.
Evaluate the given modules , run all tests declared with ' Deno . test ( ) ' and
report results to standard output :
deno test src / fetch_test . ts src / signal_test . ts
Directory arguments are expanded to all contained files matching the glob
{ * _ , * . , } test . { js , mjs , ts , mts , jsx , tsx } :
deno test src / " ,
)
. defer ( | cmd | runtime_args ( cmd , true , true )
2023-04-12 21:42:28 -04:00
. arg ( check_arg ( true ) )
2021-08-24 11:23:29 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " ignore " )
2021-08-24 11:23:29 -04:00
. long ( " ignore " )
2023-03-26 00:06:18 -04:00
. num_args ( 1 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-08-24 11:23:29 -04:00
. require_equals ( true )
2022-03-14 14:41:35 -04:00
. help ( " Ignore files " )
. value_hint ( ValueHint ::AnyPath ) ,
2021-08-24 11:23:29 -04:00
)
2020-02-28 09:17:56 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " no-run " )
2021-04-16 09:28:41 -04:00
. long ( " no-run " )
. help ( " Cache test modules, but don't run tests " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue ) ,
2021-02-21 11:58:32 -05:00
)
2022-02-25 10:14:46 -05:00
. arg (
Arg ::new ( " trace-ops " )
. long ( " trace-ops " )
. help ( " Enable tracing of async ops. Useful when debugging leaking ops in test, but impacts test execution time. " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue ) ,
2022-02-25 10:14:46 -05:00
)
2021-05-10 19:54:39 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " doc " )
2021-05-10 19:54:39 -04:00
. long ( " doc " )
2023-02-15 18:50:30 -05:00
. help ( " Type-check code blocks in JSDoc and Markdown " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue ) ,
2021-05-10 19:54:39 -04:00
)
2021-02-21 11:58:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " fail-fast " )
2021-04-16 09:28:41 -04:00
. long ( " fail-fast " )
. alias ( " failfast " )
2021-07-12 06:55:42 -04:00
. help ( " Stop after N errors. Defaults to stopping after first failure. " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2021-07-12 06:55:42 -04:00
. require_equals ( true )
. value_name ( " N " )
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( NonZeroUsize ) ) ,
2019-04-17 09:25:51 -04:00
)
2020-05-21 10:35:36 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-none " )
2021-04-16 09:28:41 -04:00
. long ( " allow-none " )
. help ( " Don't return error code if no test files are found " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue ) ,
2020-05-21 10:35:36 -04:00
)
2020-11-29 21:10:21 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " filter " )
2022-03-27 21:57:56 -04:00
. allow_hyphen_values ( true )
2021-04-16 09:28:41 -04:00
. long ( " filter " )
. help ( " Run tests with this string or pattern in the test name " ) ,
2019-11-26 11:06:32 -05:00
)
2021-07-05 21:20:33 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " shuffle " )
2021-07-05 21:20:33 -04:00
. long ( " shuffle " )
. value_name ( " NUMBER " )
2023-02-15 18:50:30 -05:00
. help ( " Shuffle the order in which the tests are run " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2021-07-05 21:20:33 -04:00
. require_equals ( true )
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( u64 ) ) ,
2021-07-05 21:20:33 -04:00
)
2020-07-08 10:50:12 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " coverage " )
2021-04-16 09:28:41 -04:00
. long ( " coverage " )
2021-08-12 04:21:38 -04:00
. value_name ( " DIR " )
2023-12-08 03:35:42 -05:00
. num_args ( 0 ..= 1 )
. require_equals ( true )
. default_missing_value ( " coverage " )
2021-04-16 09:28:41 -04:00
. conflicts_with ( " inspect " )
2022-12-12 09:33:30 -05:00
. conflicts_with ( " inspect-wait " )
2021-04-16 09:28:41 -04:00
. conflicts_with ( " inspect-brk " )
2023-12-08 03:35:42 -05:00
. help ( " Collect coverage profile data into DIR. If DIR is not specified, it uses 'coverage/'. " ) ,
2020-07-08 10:50:12 -04:00
)
2022-07-20 17:36:54 -04:00
. arg (
Arg ::new ( " parallel " )
. long ( " parallel " )
. help ( " Run test modules in parallel. Parallelism defaults to the number of available CPUs or the value in the DENO_JOBS environment variable. " )
. conflicts_with ( " jobs " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-07-20 17:36:54 -04:00
)
2021-04-28 14:17:04 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " jobs " )
. short ( 'j' )
2021-04-28 14:17:04 -04:00
. long ( " jobs " )
2022-07-20 17:36:54 -04:00
. help ( " deprecated: Number of parallel workers, defaults to number of available CPUs when no value is provided. Defaults to 1 when the option is not present. " )
. hide ( true )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( NonZeroUsize ) ) ,
2021-04-28 14:17:04 -04:00
)
2020-01-31 16:07:37 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " files " )
2021-04-16 09:28:41 -04:00
. help ( " List of file names to run " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
. action ( ArgAction ::Append )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::AnyPath ) ,
2020-01-31 16:07:37 -05:00
)
2021-05-10 02:06:13 -04:00
. arg (
2021-12-15 16:04:43 -05:00
watch_arg ( false )
2021-05-10 02:06:13 -04:00
. conflicts_with ( " no-run " )
. conflicts_with ( " coverage " ) ,
)
2022-01-31 11:39:39 -05:00
. arg ( no_clear_screen_arg ( ) )
2021-04-16 09:28:41 -04:00
. arg ( script_arg ( ) . last ( true ) )
2023-07-26 18:12:35 -04:00
. arg (
2023-08-02 22:05:34 -04:00
Arg ::new ( " junit-path " )
. long ( " junit-path " )
2023-07-26 18:12:35 -04:00
. value_name ( " PATH " )
. value_hint ( ValueHint ::FilePath )
. help ( " Write a JUnit XML test report to PATH. Use '-' to write to stdout which is the default when PATH is not provided. " )
)
2023-08-02 12:38:10 -04:00
. arg (
2023-08-02 22:05:34 -04:00
Arg ::new ( " reporter " )
. long ( " reporter " )
. help ( " Select reporter to use. Default to 'pretty'. " )
2023-08-25 19:19:23 -04:00
. value_parser ( [ " pretty " , " dot " , " junit " , " tap " ] )
2023-08-02 12:38:10 -04:00
)
2023-11-01 11:21:13 -04:00
. arg ( env_file_arg ( ) )
2023-06-27 20:57:20 -04:00
)
2019-06-05 13:44:46 -04:00
}
2023-03-26 00:06:18 -04:00
fn types_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " types " )
. about ( " Print runtime TypeScript declarations " )
. long_about (
" Print runtime TypeScript declarations.
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno types > lib . deno . d . ts
2021-02-24 09:27:51 -05:00
2021-04-16 09:28:41 -04:00
The declaration file could be saved and used for typing information . " ,
2023-06-27 20:57:20 -04:00
)
2021-04-16 09:28:41 -04:00
}
2021-02-24 09:27:51 -05:00
2023-03-26 00:06:18 -04:00
fn upgrade_subcommand ( ) -> Command {
2023-06-27 20:57:20 -04:00
Command ::new ( " upgrade " )
. about ( " Upgrade deno executable to given version " )
. long_about (
" Upgrade deno executable to the given version.
2021-04-16 09:28:41 -04:00
Defaults to latest .
2021-02-24 09:27:51 -05:00
2021-04-16 09:28:41 -04:00
The version is downloaded from
https ://github.com/denoland/deno/releases
and is used to replace the current executable .
2021-02-24 09:27:51 -05:00
2021-04-16 09:28:41 -04:00
If you want to not replace the current Deno executable but instead download an
update to a different location , use the - - output flag
2021-04-18 09:12:55 -04:00
2021-04-16 09:28:41 -04:00
deno upgrade - - output $HOME / my_deno " ,
2023-06-27 20:57:20 -04:00
)
2023-11-29 13:52:25 -05:00
. hide ( cfg! ( not ( feature = " upgrade " ) ) )
2023-06-27 20:57:20 -04:00
. defer ( | cmd | {
cmd
. arg (
Arg ::new ( " version " )
. long ( " version " )
. help ( " The version to upgrade to " ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " The path to output the updated version to " )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-06-27 20:57:20 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " dry-run " )
. long ( " dry-run " )
. help ( " Perform all checks without replacing old exe " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help ( " Replace current exe even if not out-of-date " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " canary " )
. long ( " canary " )
. help ( " Upgrade to canary builds " )
. action ( ArgAction ::SetTrue ) ,
)
. arg ( ca_file_arg ( ) )
} )
2020-03-23 11:37:24 -04:00
}
2023-03-26 00:06:18 -04:00
fn vendor_subcommand ( ) -> Command {
2022-03-27 21:57:56 -04:00
Command ::new ( " vendor " )
2023-06-27 20:57:20 -04:00
. about ( " Vendor remote modules into a local directory " )
2023-06-12 07:54:04 -04:00
. long_about (
" Vendor remote modules into a local directory.
2022-02-16 13:14:19 -05:00
Analyzes the provided modules along with their dependencies , downloads
remote modules to the output directory , and produces an import map that
maps remote specifiers to the downloaded files .
deno vendor main . ts
deno run - - import - map vendor / import_map . json main . ts
Remote modules and multiple modules may also be specified :
deno vendor main . ts test . deps . ts https ://deno.land/std/path/mod.ts",
2023-06-12 07:54:04 -04:00
)
2023-06-27 20:57:20 -04:00
. defer ( | cmd | cmd
2023-06-12 07:54:04 -04:00
. arg (
Arg ::new ( " specifiers " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. required ( true ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " The directory to output the vendored modules to " )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-06-12 07:54:04 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. value_hint ( ValueHint ::DirPath ) ,
)
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help (
" Forcefully overwrite conflicting files in existing output directory " ,
)
. action ( ArgAction ::SetTrue ) ,
)
. arg ( no_config_arg ( ) )
. arg ( config_arg ( ) )
. arg ( import_map_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( node_modules_dir_arg ( ) )
2023-08-06 21:56:56 -04:00
. arg ( vendor_arg ( ) )
2023-06-12 07:54:04 -04:00
. arg ( reload_arg ( ) )
. arg ( ca_file_arg ( ) ) )
2022-02-16 13:14:19 -05:00
}
2023-11-23 18:38:07 -05:00
fn publish_subcommand ( ) -> Command {
2024-01-08 15:07:36 -05:00
Command ::new ( " publish " )
2023-11-23 18:38:07 -05:00
. hide ( true )
2024-01-10 17:40:30 -05:00
. about ( " Unstable preview feature: Publish the current working directory's package or workspace " )
2023-11-23 18:38:07 -05:00
// TODO: .long_about()
. defer ( | cmd | {
cmd . arg (
Arg ::new ( " token " )
2023-11-24 08:05:47 -05:00
. long ( " token " )
. help ( " The API token to use when publishing. If unset, interactive authentication is be used " )
2023-11-23 18:38:07 -05:00
)
2024-01-11 16:17:03 -05:00
. arg (
Arg ::new ( " dry-run " )
. long ( " dry-run " )
. help ( " Prepare the package for publishing performing all checks and validations without uploading " )
. action ( ArgAction ::SetTrue ) ,
)
2023-11-23 18:38:07 -05:00
} )
}
2022-03-27 21:57:56 -04:00
fn compile_args ( app : Command ) -> Command {
2023-04-12 21:42:28 -04:00
compile_args_without_check_args ( app . arg ( no_check_arg ( ) ) )
2020-06-08 08:06:20 -04:00
}
2022-05-17 17:53:42 -04:00
fn compile_args_without_check_args ( app : Command ) -> Command {
2022-04-10 19:12:51 -04:00
app
. arg ( import_map_arg ( ) )
. arg ( no_remote_arg ( ) )
2022-09-07 09:33:51 -04:00
. arg ( no_npm_arg ( ) )
2023-05-19 18:39:27 -04:00
. arg ( node_modules_dir_arg ( ) )
2023-08-06 21:56:56 -04:00
. arg ( vendor_arg ( ) )
2022-06-28 15:47:51 -04:00
. arg ( config_arg ( ) )
. arg ( no_config_arg ( ) )
2022-04-10 19:12:51 -04:00
. arg ( reload_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( lock_write_arg ( ) )
2022-11-03 11:42:56 -04:00
. arg ( no_lock_arg ( ) )
2022-04-10 19:12:51 -04:00
. arg ( ca_file_arg ( ) )
}
2023-04-26 20:49:59 -04:00
static ALLOW_READ_HELP : & str = concat! (
" Allow file system read access. Optionally specify allowed paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-read \n " ,
" --allow-read= \" /etc,/var/log.txt \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_READ_HELP : & str = concat! (
" Deny file system read access. Optionally specify denied paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-read \n " ,
" --deny-read= \" /etc,/var/log.txt \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_WRITE_HELP : & str = concat! (
" Allow file system write access. Optionally specify allowed paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-write \n " ,
" --allow-write= \" /etc,/var/log.txt \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_WRITE_HELP : & str = concat! (
" Deny file system write access. Optionally specify denied paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-write \n " ,
" --deny-write= \" /etc,/var/log.txt \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_NET_HELP : & str = concat! (
" Allow network access. Optionally specify allowed IP addresses and host names, with ports as necessary. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-net \n " ,
" --allow-net= \" localhost:8080,deno.land \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_NET_HELP : & str = concat! (
" Deny network access. Optionally specify denied IP addresses and host names, with ports as necessary. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-net \n " ,
" --deny-net= \" localhost:8080,deno.land \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_ENV_HELP : & str = concat! (
" Allow access to system environment information. Optionally specify accessible environment variables. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-env \n " ,
" --allow-env= \" PORT,HOME,PATH \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_ENV_HELP : & str = concat! (
" Deny access to system environment information. Optionally specify accessible environment variables. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-env \n " ,
" --deny-env= \" PORT,HOME,PATH \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_SYS_HELP : & str = concat! (
" Allow access to OS information. Optionally allow specific APIs by function name. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-sys \n " ,
" --allow-sys= \" systemMemoryInfo,osRelease \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_SYS_HELP : & str = concat! (
" Deny access to OS information. Optionally deny specific APIs by function name. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-sys \n " ,
" --deny-sys= \" systemMemoryInfo,osRelease \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_RUN_HELP : & str = concat! (
" Allow running subprocesses. Optionally specify allowed runnable program names. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-run \n " ,
" --allow-run= \" whoami,ps \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_RUN_HELP : & str = concat! (
" Deny running subprocesses. Optionally specify denied runnable program names. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-run \n " ,
" --deny-run= \" whoami,ps \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_FFI_HELP : & str = concat! (
" (Unstable) Allow loading dynamic libraries. Optionally specify allowed directories or files. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-ffi \n " ,
" --allow-ffi= \" ./libfoo.so \" "
) ;
2023-08-03 07:19:19 -04:00
static DENY_FFI_HELP : & str = concat! (
" (Unstable) Deny loading dynamic libraries. Optionally specify denied directories or files. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-ffi \n " ,
" --deny-ffi= \" ./libfoo.so \" "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_HRTIME_HELP : & str = concat! (
" Allow high-resolution time measurement. Note: this can enable timing attacks and fingerprinting. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n "
) ;
2023-08-03 07:19:19 -04:00
static DENY_HRTIME_HELP : & str = concat! (
" Deny high-resolution time measurement. Note: this can prevent timing attacks and fingerprinting. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n "
) ;
2023-04-26 20:49:59 -04:00
static ALLOW_ALL_HELP : & str = concat! (
" Allow all permissions. Learn more about permissions in Deno: \n " ,
" https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n "
) ;
2022-03-27 21:57:56 -04:00
fn permission_args ( app : Command ) -> Command {
2019-11-26 11:06:32 -05:00
app
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-read " )
2019-11-26 11:06:32 -05:00
. long ( " allow-read " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2019-11-26 11:06:32 -05:00
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " PATH " )
. help ( ALLOW_READ_HELP )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( PathBuf ) )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 11:06:32 -05:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-read " )
. long ( " deny-read " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PATH " )
. help ( DENY_READ_HELP )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-08-03 07:19:19 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. value_hint ( ValueHint ::AnyPath ) ,
)
2019-11-26 11:06:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-write " )
2019-11-26 11:06:32 -05:00
. long ( " allow-write " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2019-11-26 11:06:32 -05:00
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " PATH " )
. help ( ALLOW_WRITE_HELP )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( PathBuf ) )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 11:06:32 -05:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-write " )
. long ( " deny-write " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PATH " )
. help ( DENY_WRITE_HELP )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-08-03 07:19:19 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. value_hint ( ValueHint ::AnyPath ) ,
)
2019-11-26 11:06:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-net " )
2019-11-26 11:06:32 -05:00
. long ( " allow-net " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2019-11-26 11:06:32 -05:00
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " IP_OR_HOSTNAME " )
. help ( ALLOW_NET_HELP )
2023-08-03 07:19:19 -04:00
. value_parser ( flags_net ::validator ) ,
)
. arg (
Arg ::new ( " deny-net " )
. long ( " deny-net " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " IP_OR_HOSTNAME " )
. help ( DENY_NET_HELP )
. value_parser ( flags_net ::validator ) ,
2019-11-26 11:06:32 -05:00
)
2022-01-14 11:38:17 -05:00
. arg ( unsafely_ignore_certificate_errors_arg ( ) )
2019-11-26 11:06:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-env " )
2019-11-26 11:06:32 -05:00
. long ( " allow-env " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-04-13 07:25:21 -04:00
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " VARIABLE_NAME " )
. help ( ALLOW_ENV_HELP )
2023-03-26 00:06:18 -04:00
. value_parser ( | key : & str | {
if key . is_empty ( ) | | key . contains ( & [ '=' , '\0' ] as & [ char ] ) {
return Err ( format! ( " invalid key \" {key} \" " ) ) ;
2021-04-13 07:25:21 -04:00
}
2023-03-26 00:06:18 -04:00
Ok ( if cfg! ( windows ) {
key . to_uppercase ( )
} else {
key . to_string ( )
} )
2021-04-13 07:25:21 -04:00
} ) ,
2019-11-26 11:06:32 -05:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-env " )
. long ( " deny-env " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " VARIABLE_NAME " )
. help ( DENY_ENV_HELP )
. value_parser ( | key : & str | {
if key . is_empty ( ) | | key . contains ( & [ '=' , '\0' ] as & [ char ] ) {
return Err ( format! ( " invalid key \" {key} \" " ) ) ;
}
Ok ( if cfg! ( windows ) {
key . to_uppercase ( )
} else {
key . to_string ( )
} )
} ) ,
)
2022-09-28 08:46:50 -04:00
. arg (
Arg ::new ( " allow-sys " )
. long ( " allow-sys " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-09-28 08:46:50 -04:00
. use_value_delimiter ( true )
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " API_NAME " )
. help ( ALLOW_SYS_HELP )
2023-03-26 00:06:18 -04:00
. value_parser ( | key : & str | parse_sys_kind ( key ) . map ( ToString ::to_string ) ) ,
2022-09-28 08:46:50 -04:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-sys " )
. long ( " deny-sys " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " API_NAME " )
. help ( DENY_SYS_HELP )
. value_parser ( | key : & str | parse_sys_kind ( key ) . map ( ToString ::to_string ) ) ,
)
2019-11-26 11:06:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-run " )
2019-11-26 11:06:32 -05:00
. long ( " allow-run " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-04-09 18:12:00 -04:00
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " PROGRAM_NAME " )
. help ( ALLOW_RUN_HELP ) ,
2019-11-26 11:06:32 -05:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-run " )
. long ( " deny-run " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PROGRAM_NAME " )
. help ( DENY_RUN_HELP ) ,
)
2019-12-05 15:30:20 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-ffi " )
2021-08-06 17:28:10 -04:00
. long ( " allow-ffi " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-08-06 17:28:10 -04:00
. require_equals ( true )
2023-04-26 20:49:59 -04:00
. value_name ( " PATH " )
. help ( ALLOW_FFI_HELP )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( PathBuf ) )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::AnyPath ) ,
2019-12-05 15:30:20 -05:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-ffi " )
. long ( " deny-ffi " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PATH " )
. help ( DENY_FFI_HELP )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-08-03 07:19:19 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. value_hint ( ValueHint ::AnyPath ) ,
)
2019-11-26 11:06:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-hrtime " )
2019-11-26 11:06:32 -05:00
. long ( " allow-hrtime " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2023-04-26 20:49:59 -04:00
. help ( ALLOW_HRTIME_HELP ) ,
2019-11-26 11:06:32 -05:00
)
2023-08-03 07:19:19 -04:00
. arg (
Arg ::new ( " deny-hrtime " )
. long ( " deny-hrtime " )
. action ( ArgAction ::SetTrue )
. help ( DENY_HRTIME_HELP ) ,
)
2019-11-26 11:06:32 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " allow-all " )
. short ( 'A' )
2019-11-26 11:06:32 -05:00
. long ( " allow-all " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2023-04-26 20:49:59 -04:00
. help ( ALLOW_ALL_HELP ) ,
2019-11-26 11:06:32 -05:00
)
2023-03-26 00:06:18 -04:00
. arg (
Arg ::new ( " prompt " )
. long ( " prompt " )
. action ( ArgAction ::SetTrue )
. hide ( true )
. help (
" deprecated: Fallback to prompt if required permission wasn't passed " ,
) ,
)
2021-04-11 22:15:43 -04:00
. arg (
2022-02-12 22:13:21 -05:00
Arg ::new ( " no-prompt " )
. long ( " no-prompt " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-02-12 22:13:21 -05:00
. help ( " Always throw if required permission wasn't passed " ) ,
2021-04-11 22:15:43 -04:00
)
2020-01-30 18:42:39 -05:00
}
2022-03-27 21:57:56 -04:00
fn runtime_args (
app : Command ,
include_perms : bool ,
include_inspector : bool ,
) -> Command {
2021-04-16 09:28:41 -04:00
let app = compile_args ( app ) ;
let app = if include_perms {
permission_args ( app )
} else {
app
} ;
let app = if include_inspector {
inspect_args ( app )
} else {
app
} ;
app
. arg ( cached_only_arg ( ) )
. arg ( location_arg ( ) )
. arg ( v8_flags_arg ( ) )
. arg ( seed_arg ( ) )
2021-07-23 10:31:16 -04:00
. arg ( enable_testing_features_arg ( ) )
2023-11-10 12:41:24 -05:00
. arg ( strace_ops_arg ( ) )
2021-04-16 09:28:41 -04:00
}
2022-03-27 21:57:56 -04:00
fn inspect_args ( app : Command ) -> Command {
2021-04-16 09:28:41 -04:00
app
2020-12-11 07:18:30 -05:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " inspect " )
2021-04-16 09:28:41 -04:00
. long ( " inspect " )
2023-01-09 07:29:43 -05:00
. value_name ( " HOST_AND_PORT " )
2021-04-16 09:28:41 -04:00
. help ( " Activate inspector on host:port (default: 127.0.0.1:9229) " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2021-04-16 09:28:41 -04:00
. require_equals ( true )
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( SocketAddr ) ) ,
2020-12-11 07:18:30 -05:00
)
2020-10-25 20:25:43 -04:00
. arg (
2022-01-14 11:38:17 -05:00
Arg ::new ( " inspect-brk " )
2021-04-16 09:28:41 -04:00
. long ( " inspect-brk " )
2023-01-09 07:29:43 -05:00
. value_name ( " HOST_AND_PORT " )
2021-04-16 09:28:41 -04:00
. help (
2022-12-12 09:33:30 -05:00
" Activate inspector on host:port, wait for debugger to connect and break at the start of user script " ,
)
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2022-12-12 09:33:30 -05:00
. require_equals ( true )
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( SocketAddr ) ) ,
2022-12-12 09:33:30 -05:00
)
. arg (
Arg ::new ( " inspect-wait " )
. long ( " inspect-wait " )
2023-01-09 07:29:43 -05:00
. value_name ( " HOST_AND_PORT " )
2022-12-12 09:33:30 -05:00
. help (
" Activate inspector on host:port and wait for debugger to connect before running user code " ,
2021-04-16 09:28:41 -04:00
)
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2021-04-16 09:28:41 -04:00
. require_equals ( true )
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( SocketAddr ) ) ,
2019-11-26 11:06:32 -05:00
)
2019-04-29 19:43:06 -04:00
}
2023-03-27 12:28:41 -04:00
static IMPORT_MAP_HELP : & str = concat! (
" Load import map file from local file or remote URL.
2024-01-06 05:55:28 -05:00
Docs : https ://docs.deno.com/runtime/manual/basics/import_maps
2023-03-27 12:28:41 -04:00
Specification : https ://wicg.github.io/import-maps/
Examples : https ://github.com/WICG/import-maps#the-import-map",
) ;
2022-05-09 14:16:34 -04:00
2023-03-26 00:06:18 -04:00
fn import_map_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " import-map " )
2021-04-16 09:28:41 -04:00
. long ( " import-map " )
. alias ( " importmap " )
. value_name ( " FILE " )
. help ( " Load import map file " )
2023-03-27 12:28:41 -04:00
. long_help ( IMPORT_MAP_HELP )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 09:28:41 -04:00
}
2023-11-01 11:21:13 -04:00
fn env_file_arg ( ) -> Arg {
Arg ::new ( " env " )
. long ( " env " )
. value_name ( " FILE " )
. help ( " Load .env file " )
. long_help ( " UNSTABLE: Load environment variables from local file. Only the first environment variable with a given key is used. Existing process environment variables are not overwritten. " )
. value_hint ( ValueHint ::FilePath )
. default_missing_value ( " .env " )
. require_equals ( true )
. num_args ( 0 ..= 1 )
}
2023-03-26 00:06:18 -04:00
fn reload_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " reload " )
. short ( 'r' )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-04-16 09:28:41 -04:00
. require_equals ( true )
. long ( " reload " )
. help ( " Reload source code cache (recompile TypeScript) " )
. value_name ( " CACHE_BLOCKLIST " )
. long_help (
" Reload source code cache (recompile TypeScript)
- - reload
Reload everything
- - reload = https ://deno.land/std
Reload only standard modules
- - reload = https ://deno.land/std/fs/utils.ts,https://deno.land/std/fmt/colors.ts
2022-09-22 10:39:58 -04:00
Reloads specific modules
- - reload = npm :
Reload all npm modules
- - reload = npm :chalk
Reload specific npm module " ,
2020-09-13 09:01:30 -04:00
)
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::FilePath )
2023-03-26 00:06:18 -04:00
. value_parser ( reload_arg_validate )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn ca_file_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " cert " )
2021-04-16 09:28:41 -04:00
. long ( " cert " )
. value_name ( " FILE " )
. help ( " Load certificate authority from PEM encoded file " )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn cached_only_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " cached-only " )
2021-04-16 09:28:41 -04:00
. long ( " cached-only " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2021-04-16 09:28:41 -04:00
. help ( " Require that remote dependencies are already cached " )
}
2023-03-22 10:15:53 -04:00
/// Used for subcommands that operate on executable scripts only.
/// `deno fmt` has its own `--ext` arg because its possible values differ.
/// If --ext is not provided and the script doesn't have a file extension,
/// deno_graph::parse_module() defaults to js.
2023-03-26 00:06:18 -04:00
fn executable_ext_arg ( ) -> Arg {
2023-03-22 10:15:53 -04:00
Arg ::new ( " ext " )
. long ( " ext " )
. help ( " Set content type of the supplied file " )
2023-03-26 00:06:18 -04:00
. value_parser ( [ " ts " , " tsx " , " js " , " jsx " ] )
2023-03-22 10:15:53 -04:00
}
2023-03-26 00:06:18 -04:00
fn location_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " location " )
2021-04-16 09:28:41 -04:00
. long ( " location " )
. value_name ( " HREF " )
2023-03-26 00:06:18 -04:00
. value_parser ( | href : & str | -> Result < Url , String > {
2022-01-14 11:38:17 -05:00
let url = Url ::parse ( href ) ;
2021-04-16 09:28:41 -04:00
if url . is_err ( ) {
return Err ( " Failed to parse URL " . to_string ( ) ) ;
}
let mut url = url . unwrap ( ) ;
if ! [ " http " , " https " ] . contains ( & url . scheme ( ) ) {
return Err ( " Expected protocol \" http \" or \" https \" " . to_string ( ) ) ;
}
url . set_username ( " " ) . unwrap ( ) ;
url . set_password ( None ) . unwrap ( ) ;
2023-03-26 00:06:18 -04:00
Ok ( url )
2021-04-16 09:28:41 -04:00
} )
. help ( " Value of 'globalThis.location' used by some web APIs " )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::Url )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn enable_testing_features_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " enable-testing-features-do-not-use " )
2021-07-23 10:31:16 -04:00
. long ( " enable-testing-features-do-not-use " )
. help ( " INTERNAL: Enable internal features used during integration testing " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-01-14 11:38:17 -05:00
. hide ( true )
2021-07-23 10:31:16 -04:00
}
2023-11-10 12:41:24 -05:00
fn strace_ops_arg ( ) -> Arg {
Arg ::new ( " strace-ops " )
. long ( " strace-ops " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " OPS " )
. help ( " Trace low-level op calls " )
. hide ( true )
}
2023-03-26 00:06:18 -04:00
fn v8_flags_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " v8-flags " )
2021-04-16 09:28:41 -04:00
. long ( " v8-flags " )
2023-03-26 00:06:18 -04:00
. num_args ( .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-04-16 09:28:41 -04:00
. require_equals ( true )
2022-04-11 01:01:02 -04:00
. help ( " Set V8 command line options " )
2023-03-27 12:28:41 -04:00
. long_help ( " To see a list of all available flags use --v8-flags=--help.
2023-01-24 23:03:03 -05:00
Any flags set with this flag are appended after the DENO_V8_FLAGS environmental variable " )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn seed_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " seed " )
2021-04-16 09:28:41 -04:00
. long ( " seed " )
. value_name ( " NUMBER " )
2022-04-11 01:01:02 -04:00
. help ( " Set the random number generator seed " )
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( u64 ) )
2021-04-16 09:28:41 -04:00
}
2023-10-30 20:25:58 -04:00
fn hmr_arg ( takes_files : bool ) -> Arg {
let arg = Arg ::new ( " hmr " )
. long ( " unstable-hmr " )
. help ( " UNSTABLE: Watch for file changes and hot replace modules " )
. conflicts_with ( " watch " ) ;
if takes_files {
arg
. value_name ( " FILES " )
. num_args ( 0 .. )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-10-30 20:25:58 -04:00
. value_parser ( value_parser! ( PathBuf ) )
. use_value_delimiter ( true )
. require_equals ( true )
. long_help (
" Watch for file changes and restart process automatically.
Local files from entry point module graph are watched by default .
Additional paths might be watched by passing them as arguments to this flag . " ,
)
. value_hint ( ValueHint ::AnyPath )
} else {
arg . action ( ArgAction ::SetTrue ) . long_help (
" Watch for file changes and restart process automatically.
Only local files from entry point module graph are watched . " ,
)
}
}
2023-03-26 00:06:18 -04:00
fn watch_arg ( takes_files : bool ) -> Arg {
2022-01-14 11:38:17 -05:00
let arg = Arg ::new ( " watch " )
2021-04-16 09:28:41 -04:00
. long ( " watch " )
2022-06-26 18:28:45 -04:00
. help ( " Watch for file changes and restart automatically " ) ;
2021-12-15 16:04:43 -05:00
if takes_files {
arg
. value_name ( " FILES " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( PathBuf ) )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-12-15 16:04:43 -05:00
. require_equals ( true )
. long_help (
2022-06-26 18:28:45 -04:00
" Watch for file changes and restart process automatically.
2021-12-15 16:04:43 -05:00
Local files from entry point module graph are watched by default .
Additional paths might be watched by passing them as arguments to this flag . " ,
)
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::AnyPath )
2021-12-15 16:04:43 -05:00
} else {
2023-03-26 00:06:18 -04:00
arg . action ( ArgAction ::SetTrue ) . long_help (
2023-03-27 12:28:41 -04:00
" Watch for file changes and restart process automatically.
2022-04-11 01:01:02 -04:00
Only local files from entry point module graph are watched . " ,
2019-11-26 11:06:32 -05:00
)
2021-12-15 16:04:43 -05:00
}
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn no_clear_screen_arg ( ) -> Arg {
2022-01-31 11:39:39 -05:00
Arg ::new ( " no-clear-screen " )
. requires ( " watch " )
. long ( " no-clear-screen " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-01-31 11:39:39 -05:00
. help ( " Do not clear terminal screen when under watch mode " )
}
2023-03-26 00:06:18 -04:00
fn no_check_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " no-check " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2021-11-29 17:23:30 -05:00
. require_equals ( true )
. value_name ( " NO_CHECK_TYPE " )
2021-04-16 09:28:41 -04:00
. long ( " no-check " )
2022-06-18 12:11:15 -04:00
. help ( " Skip type-checking modules " )
2021-11-29 17:23:30 -05:00
. long_help (
2023-03-27 12:28:41 -04:00
" Skip type-checking. If the value of '--no-check=remote' is supplied,
diagnostic errors from remote modules will be ignored . " ,
2021-11-29 17:23:30 -05:00
)
2021-04-16 09:28:41 -04:00
}
2023-04-12 21:42:28 -04:00
fn check_arg ( checks_local_by_default : bool ) -> Arg {
let arg = Arg ::new ( " check " )
2022-04-10 19:12:51 -04:00
. conflicts_with ( " no-check " )
. long ( " check " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2022-04-10 19:12:51 -04:00
. require_equals ( true )
. value_name ( " CHECK_TYPE " )
2023-04-12 21:42:28 -04:00
. help ( " Type-check modules " ) ;
2022-04-10 19:12:51 -04:00
2023-04-12 21:42:28 -04:00
if checks_local_by_default {
arg . long_help (
" Set type-checking behavior. This subcommand type-checks local modules by
default , so adding - - check is redundant .
2022-04-10 19:12:51 -04:00
If the value of ' - - check = all ' is supplied , diagnostic errors from remote modules
2023-04-12 21:42:28 -04:00
will be included .
2023-04-26 13:07:15 -04:00
2023-04-12 21:42:28 -04:00
Alternatively , the ' deno check ' subcommand can be used . " ,
2022-04-10 19:12:51 -04:00
)
2023-04-12 21:42:28 -04:00
} else {
arg . long_help (
" Enable type-checking. This subcommand does not type-check by default.
If the value of ' - - check = all ' is supplied , diagnostic errors from remote modules
will be included .
Alternatively , the ' deno check ' subcommand can be used . " ,
)
}
2022-04-10 19:12:51 -04:00
}
2023-03-26 00:06:18 -04:00
fn script_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " script_arg " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
. action ( ArgAction ::Append )
2021-04-16 09:28:41 -04:00
// NOTE: these defaults are provided
// so `deno run --v8-flags=--help` works
// without specifying file to run.
2023-03-26 00:06:18 -04:00
. default_value_ifs ( [
( " v8-flags " , " --help " , Some ( " _ " ) ) ,
( " v8-flags " , " -help " , Some ( " _ " ) ) ,
2021-04-16 09:28:41 -04:00
] )
. help ( " Script arg " )
. value_name ( " SCRIPT_ARG " )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn lock_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " lock " )
2021-04-16 09:28:41 -04:00
. long ( " lock " )
. value_name ( " FILE " )
2023-03-30 10:43:16 -04:00
. help ( " Check the specified lock file.
2023-03-27 12:28:41 -04:00
If value is not provided , defaults to \ " deno.lock \" in the current working directory. " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
2024-01-15 19:15:39 -05:00
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string
2023-03-26 00:06:18 -04:00
. value_parser ( value_parser! ( PathBuf ) )
2022-03-14 14:41:35 -04:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn lock_write_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " lock-write " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2021-04-16 09:28:41 -04:00
. long ( " lock-write " )
2022-11-02 11:32:30 -04:00
. help ( " Force overwriting the lock file. " )
2023-03-13 17:04:00 -04:00
. conflicts_with ( " no-lock " )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn no_lock_arg ( ) -> Arg {
2022-11-03 11:42:56 -04:00
Arg ::new ( " no-lock " )
. long ( " no-lock " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-11-03 11:42:56 -04:00
. help ( " Disable auto discovery of the lock file. " )
. conflicts_with ( " lock " )
}
2023-03-27 12:28:41 -04:00
static CONFIG_HELP : & str = concat! (
" The configuration file can be used to configure different aspects of
deno including TypeScript , linting , and code formatting . Typically the
configuration file will be called ` deno . json ` or ` deno . jsonc ` and
automatically detected ; in that case this flag is not necessary .
See https ://deno.land/manual@v",
env! ( " CARGO_PKG_VERSION " ) ,
" /getting_started/configuration_file "
) ;
2022-05-09 14:16:34 -04:00
2023-03-26 00:06:18 -04:00
fn config_arg ( ) -> Arg {
2022-06-28 15:47:51 -04:00
Arg ::new ( " config " )
. short ( 'c' )
. long ( " config " )
. value_name ( " FILE " )
. help ( " Specify the configuration file " )
2023-03-27 12:28:41 -04:00
. long_help ( CONFIG_HELP )
2022-06-28 15:47:51 -04:00
. value_hint ( ValueHint ::FilePath )
}
2023-03-26 00:06:18 -04:00
fn no_config_arg ( ) -> Arg {
2022-06-28 15:47:51 -04:00
Arg ::new ( " no-config " )
. long ( " no-config " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-06-28 15:47:51 -04:00
. help ( " Disable automatic loading of the configuration file. " )
. conflicts_with ( " config " )
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn no_remote_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " no-remote " )
2021-04-16 09:28:41 -04:00
. long ( " no-remote " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2021-04-16 09:28:41 -04:00
. help ( " Do not resolve remote modules " )
}
2023-03-26 00:06:18 -04:00
fn no_npm_arg ( ) -> Arg {
2022-09-07 09:33:51 -04:00
Arg ::new ( " no-npm " )
. long ( " no-npm " )
2023-03-26 00:06:18 -04:00
. action ( ArgAction ::SetTrue )
2022-09-07 09:33:51 -04:00
. help ( " Do not resolve npm modules " )
}
2023-05-19 18:39:27 -04:00
fn node_modules_dir_arg ( ) -> Arg {
2022-09-22 11:17:02 -04:00
Arg ::new ( " node-modules-dir " )
. long ( " node-modules-dir " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
2023-02-20 13:14:06 -05:00
. require_equals ( true )
2023-05-18 18:10:44 -04:00
. help ( " Enables or disables the use of a local node_modules folder for npm packages " )
2022-09-22 11:17:02 -04:00
}
2023-08-06 21:56:56 -04:00
fn vendor_arg ( ) -> Arg {
Arg ::new ( " vendor " )
. long ( " vendor " )
2023-08-01 20:49:09 -04:00
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
2023-08-06 21:56:56 -04:00
. help ( " UNSTABLE: Enables or disables the use of a local vendor folder for remote modules and node_modules folder for npm packages " )
2023-08-01 20:49:09 -04:00
}
2023-03-26 00:06:18 -04:00
fn unsafely_ignore_certificate_errors_arg ( ) -> Arg {
2022-01-14 11:38:17 -05:00
Arg ::new ( " unsafely-ignore-certificate-errors " )
2021-12-10 09:47:55 -05:00
. long ( " unsafely-ignore-certificate-errors " )
2023-03-26 00:06:18 -04:00
. num_args ( 0 .. )
2022-03-27 21:57:56 -04:00
. use_value_delimiter ( true )
2021-12-10 09:47:55 -05:00
. require_equals ( true )
. value_name ( " HOSTNAMES " )
. help ( " DANGER: Disables verification of TLS certificates " )
2023-08-03 07:19:19 -04:00
. value_parser ( flags_net ::validator )
2021-12-10 09:47:55 -05:00
}
2023-03-26 00:06:18 -04:00
fn bench_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::Local ;
2022-03-11 17:07:02 -05:00
runtime_args_parse ( flags , matches , true , false ) ;
// NOTE: `deno bench` always uses `--no-prompt`, tests shouldn't ever do
// interactive prompts, unless done by user code
flags . no_prompt = true ;
2023-03-26 00:06:18 -04:00
let json = matches . get_flag ( " json " ) ;
2023-02-12 12:40:45 -05:00
2024-01-15 19:15:39 -05:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2022-03-11 17:07:02 -05:00
None = > vec! [ ] ,
} ;
2023-03-26 00:06:18 -04:00
let filter = matches . remove_one ::< String > ( " filter " ) ;
2022-03-11 17:07:02 -05:00
2023-03-26 00:06:18 -04:00
if matches . contains_id ( " script_arg " ) {
flags
. argv
. extend ( matches . remove_many ::< String > ( " script_arg " ) . unwrap ( ) ) ;
2022-03-11 17:07:02 -05:00
}
2024-01-15 19:15:39 -05:00
let include = if let Some ( files ) = matches . remove_many ::< String > ( " files " ) {
2023-03-26 00:06:18 -04:00
files . collect ( )
2022-03-11 17:07:02 -05:00
} else {
2023-01-07 15:22:09 -05:00
Vec ::new ( )
2022-03-11 17:07:02 -05:00
} ;
2023-03-26 10:55:58 -04:00
let no_run = matches . get_flag ( " no-run " ) ;
2022-03-11 17:07:02 -05:00
flags . subcommand = DenoSubcommand ::Bench ( BenchFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags { include , ignore } ,
2022-03-11 17:07:02 -05:00
filter ,
2023-02-12 12:40:45 -05:00
json ,
2023-03-26 10:55:58 -04:00
no_run ,
2023-06-15 13:09:37 -04:00
watch : watch_arg_parse ( matches ) ,
2022-03-11 17:07:02 -05:00
} ) ;
}
2023-03-26 00:06:18 -04:00
fn bundle_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::Local ;
2021-04-16 09:28:41 -04:00
compile_args_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
let source_file = matches . remove_one ::< String > ( " source_file " ) . unwrap ( ) ;
2021-04-16 09:28:41 -04:00
2023-03-26 00:06:18 -04:00
let out_file =
2024-01-15 19:15:39 -05:00
if let Some ( out_file ) = matches . remove_one ::< String > ( " out_file " ) {
2023-03-26 00:06:18 -04:00
flags . allow_write = Some ( vec! [ ] ) ;
Some ( out_file )
} else {
None
} ;
2021-04-16 09:28:41 -04:00
2023-03-22 10:15:53 -04:00
ext_arg_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Bundle ( BundleFlags {
2021-04-16 09:28:41 -04:00
source_file ,
out_file ,
2023-06-15 13:09:37 -04:00
watch : watch_arg_parse ( matches ) ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn cache_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
compile_args_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
let files = matches . remove_many ::< String > ( " file " ) . unwrap ( ) . collect ( ) ;
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Cache ( CacheFlags { files } ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn check_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::Local ;
2023-03-13 17:04:00 -04:00
compile_args_without_check_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
let files = matches . remove_many ::< String > ( " file " ) . unwrap ( ) . collect ( ) ;
if matches . get_flag ( " all " ) | | matches . get_flag ( " remote " ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::All ;
}
flags . subcommand = DenoSubcommand ::Check ( CheckFlags { files } ) ;
2022-04-10 19:12:51 -04:00
}
2023-03-26 00:06:18 -04:00
fn compile_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::Local ;
2021-04-16 09:28:41 -04:00
runtime_args_parse ( flags , matches , true , false ) ;
2023-03-26 00:06:18 -04:00
let mut script = matches . remove_many ::< String > ( " script_arg " ) . unwrap ( ) ;
let source_file = script . next ( ) . unwrap ( ) ;
let args = script . collect ( ) ;
let output = matches . remove_one ::< PathBuf > ( " output " ) ;
let target = matches . remove_one ::< String > ( " target " ) ;
2023-07-28 11:46:26 -04:00
let no_terminal = matches . get_flag ( " no-terminal " ) ;
2023-03-26 00:06:18 -04:00
let include = match matches . remove_many ::< String > ( " include " ) {
Some ( f ) = > f . collect ( ) ,
2023-03-18 19:43:07 -04:00
None = > vec! [ ] ,
} ;
2023-03-22 10:15:53 -04:00
ext_arg_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Compile ( CompileFlags {
2021-04-16 09:28:41 -04:00
source_file ,
output ,
args ,
target ,
2023-07-28 11:46:26 -04:00
no_terminal ,
2023-03-18 19:43:07 -04:00
include ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-04-16 09:28:41 -04:00
}
2022-01-14 11:38:17 -05:00
fn completions_parse (
flags : & mut Flags ,
2023-03-26 00:06:18 -04:00
matches : & mut ArgMatches ,
mut app : Command ,
2022-01-14 11:38:17 -05:00
) {
use clap_complete ::generate ;
2023-01-14 23:18:58 -05:00
use clap_complete ::shells ::Bash ;
use clap_complete ::shells ::Fish ;
use clap_complete ::shells ::PowerShell ;
use clap_complete ::shells ::Zsh ;
2022-01-14 11:38:17 -05:00
use clap_complete_fig ::Fig ;
2021-04-16 09:28:41 -04:00
let mut buf : Vec < u8 > = vec! [ ] ;
2022-01-14 11:38:17 -05:00
let name = " deno " ;
2023-03-26 00:06:18 -04:00
match matches . get_one ::< String > ( " shell " ) . unwrap ( ) . as_str ( ) {
2022-01-14 11:38:17 -05:00
" bash " = > generate ( Bash , & mut app , name , & mut buf ) ,
" fish " = > generate ( Fish , & mut app , name , & mut buf ) ,
" powershell " = > generate ( PowerShell , & mut app , name , & mut buf ) ,
" zsh " = > generate ( Zsh , & mut app , name , & mut buf ) ,
" fig " = > generate ( Fig , & mut app , name , & mut buf ) ,
_ = > unreachable! ( ) ,
}
2021-04-16 09:28:41 -04:00
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Completions ( CompletionsFlags {
2021-04-16 09:28:41 -04:00
buf : buf . into_boxed_slice ( ) ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn coverage_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2024-01-15 19:15:39 -05:00
let files = match matches . remove_many ::< String > ( " files " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2024-01-15 19:15:39 -05:00
None = > vec! [ " coverage " . to_string ( ) ] , // default
2021-04-16 09:28:41 -04:00
} ;
2024-01-15 19:15:39 -05:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2023-03-26 00:06:18 -04:00
let include = match matches . remove_many ::< String > ( " include " ) {
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2023-03-26 00:06:18 -04:00
let exclude = match matches . remove_many ::< String > ( " exclude " ) {
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2023-12-08 02:54:52 -05:00
let r#type = if matches . get_flag ( " lcov " ) {
CoverageType ::Lcov
} else if matches . get_flag ( " html " ) {
CoverageType ::Html
2023-12-12 06:53:41 -05:00
} else if matches . get_flag ( " detailed " ) {
CoverageType ::Detailed
2023-12-11 22:42:57 -05:00
} else {
CoverageType ::Summary
2023-12-08 02:54:52 -05:00
} ;
2023-03-26 00:06:18 -04:00
let output = matches . remove_one ::< PathBuf > ( " output " ) ;
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Coverage ( CoverageFlags {
2023-01-13 16:56:29 -05:00
files : FileFlags {
include : files ,
ignore ,
} ,
2022-02-15 10:33:21 -05:00
output ,
2021-04-16 09:28:41 -04:00
include ,
exclude ,
2023-12-08 02:54:52 -05:00
r#type ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn doc_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
import_map_arg_parse ( flags , matches ) ;
reload_arg_parse ( flags , matches ) ;
2023-03-13 17:04:00 -04:00
lock_arg_parse ( flags , matches ) ;
no_lock_arg_parse ( flags , matches ) ;
no_npm_arg_parse ( flags , matches ) ;
no_remote_arg_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
2023-10-30 18:58:57 -04:00
let source_files_val = matches . remove_many ::< String > ( " source_file " ) ;
let source_files = if let Some ( val ) = source_files_val {
let vals : Vec < String > = val . collect ( ) ;
if vals . len ( ) = = 1 {
if vals [ 0 ] = = " --builtin " {
2023-01-14 12:39:56 -05:00
DocSourceFileFlag ::Builtin
} else {
2023-10-30 18:58:57 -04:00
DocSourceFileFlag ::Paths ( vec! [ vals [ 0 ] . to_string ( ) ] )
2023-01-14 12:39:56 -05:00
}
2023-10-30 18:58:57 -04:00
} else {
DocSourceFileFlag ::Paths (
vals . into_iter ( ) . filter ( | v | v ! = " --builtin " ) . collect ( ) ,
)
}
} else {
DocSourceFileFlag ::Builtin
} ;
2023-03-26 00:06:18 -04:00
let private = matches . get_flag ( " private " ) ;
2023-10-31 18:19:42 -04:00
let lint = matches . get_flag ( " lint " ) ;
2023-03-26 00:06:18 -04:00
let json = matches . get_flag ( " json " ) ;
let filter = matches . remove_one ::< String > ( " filter " ) ;
2023-11-01 11:25:05 -04:00
let html = if matches . get_flag ( " html " ) {
let name = matches . remove_one ::< String > ( " name " ) . unwrap ( ) ;
let output = matches
. remove_one ::< PathBuf > ( " output " )
. unwrap_or ( PathBuf ::from ( " ./docs/ " ) ) ;
Some ( DocHtmlFlag { name , output } )
} else {
None
} ;
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Doc ( DocFlags {
2023-10-30 18:58:57 -04:00
source_files ,
2021-04-16 09:28:41 -04:00
json ,
2023-10-31 18:19:42 -04:00
lint ,
2023-11-01 11:25:05 -04:00
html ,
2021-04-16 09:28:41 -04:00
filter ,
private ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn eval_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
runtime_args_parse ( flags , matches , false , true ) ;
flags . allow_net = Some ( vec! [ ] ) ;
flags . allow_env = Some ( vec! [ ] ) ;
flags . allow_run = Some ( vec! [ ] ) ;
flags . allow_read = Some ( vec! [ ] ) ;
2022-09-28 08:46:50 -04:00
flags . allow_sys = Some ( vec! [ ] ) ;
2021-04-16 09:28:41 -04:00
flags . allow_write = Some ( vec! [ ] ) ;
2021-08-06 17:28:10 -04:00
flags . allow_ffi = Some ( vec! [ ] ) ;
2021-04-16 09:28:41 -04:00
flags . allow_hrtime = true ;
2023-03-22 10:15:53 -04:00
ext_arg_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
// TODO(@satyarohith): remove this flag in 2.0.
2023-03-26 00:06:18 -04:00
let as_typescript = matches . get_flag ( " ts " ) ;
2023-03-22 10:15:53 -04:00
if as_typescript {
eprintln! (
" {} " ,
crate ::colors ::yellow (
" Warning: --ts/-T flag is deprecated. Use --ext=ts instead. "
) ,
) ;
flags . ext = Some ( " ts " . to_string ( ) ) ;
}
2021-04-16 09:28:41 -04:00
2023-03-26 00:06:18 -04:00
let print = matches . get_flag ( " print " ) ;
let mut code_args = matches . remove_many ::< String > ( " code_arg " ) . unwrap ( ) ;
let code = code_args . next ( ) . unwrap ( ) ;
flags . argv . extend ( code_args ) ;
2023-03-22 10:15:53 -04:00
flags . subcommand = DenoSubcommand ::Eval ( EvalFlags { print , code } ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
fn fmt_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-05-13 11:40:50 -04:00
config_args_parse ( flags , matches ) ;
2023-03-22 10:15:53 -04:00
ext_arg_parse ( flags , matches ) ;
2022-01-31 11:39:39 -05:00
2024-01-15 19:15:39 -05:00
let include = match matches . remove_many ::< String > ( " files " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2024-01-15 19:15:39 -05:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2019-04-29 19:43:06 -04:00
2023-03-26 00:06:18 -04:00
let use_tabs = matches . remove_one ::< bool > ( " use-tabs " ) ;
let line_width = matches . remove_one ::< NonZeroU32 > ( " line-width " ) ;
let indent_width = matches . remove_one ::< NonZeroU8 > ( " indent-width " ) ;
let single_quote = matches . remove_one ::< bool > ( " single-quote " ) ;
let prose_wrap = matches . remove_one ::< String > ( " prose-wrap " ) ;
let no_semicolons = matches . remove_one ::< bool > ( " no-semicolons " ) ;
2021-09-13 16:06:45 -04:00
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Fmt ( FmtFlags {
2023-03-26 00:06:18 -04:00
check : matches . get_flag ( " check " ) ,
2023-01-07 15:22:09 -05:00
files : FileFlags { include , ignore } ,
2021-09-13 16:06:45 -04:00
use_tabs ,
line_width ,
indent_width ,
single_quote ,
prose_wrap ,
2023-01-25 15:06:00 -05:00
no_semicolons ,
2023-06-15 13:09:37 -04:00
watch : watch_arg_parse ( matches ) ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-04-16 09:28:41 -04:00
}
2019-07-27 05:20:40 -04:00
2023-03-26 00:06:18 -04:00
fn init_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-08-19 19:37:05 -04:00
flags . subcommand = DenoSubcommand ::Init ( InitFlags {
2023-03-26 00:06:18 -04:00
dir : matches . remove_one ::< String > ( " dir " ) ,
2022-08-19 19:37:05 -04:00
} ) ;
}
2023-03-26 00:06:18 -04:00
fn info_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
reload_arg_parse ( flags , matches ) ;
2022-06-13 14:09:04 -04:00
config_args_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
import_map_arg_parse ( flags , matches ) ;
2021-05-27 01:23:12 -04:00
location_arg_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
ca_file_arg_parse ( flags , matches ) ;
2023-08-06 21:56:56 -04:00
node_modules_and_vendor_dir_arg_parse ( flags , matches ) ;
2023-03-13 17:04:00 -04:00
lock_arg_parse ( flags , matches ) ;
no_lock_arg_parse ( flags , matches ) ;
no_remote_arg_parse ( flags , matches ) ;
no_npm_arg_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
let json = matches . get_flag ( " json " ) ;
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Info ( InfoFlags {
2023-03-26 00:06:18 -04:00
file : matches . remove_one ::< String > ( " file " ) ,
2021-04-16 09:28:41 -04:00
json ,
2021-09-03 19:33:35 -04:00
} ) ;
2019-11-26 11:06:32 -05:00
}
2019-05-16 10:11:35 -04:00
2023-03-26 00:06:18 -04:00
fn install_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
runtime_args_parse ( flags , matches , true , true ) ;
2023-11-13 09:44:01 -05:00
let root = matches . remove_one ::< String > ( " root " ) ;
2021-04-16 09:28:41 -04:00
2023-03-26 00:06:18 -04:00
let force = matches . get_flag ( " force " ) ;
let name = matches . remove_one ::< String > ( " name " ) ;
let mut cmd_values = matches . remove_many ::< String > ( " cmd " ) . unwrap ( ) ;
2021-04-16 09:28:41 -04:00
2023-03-26 00:06:18 -04:00
let module_url = cmd_values . next ( ) . unwrap ( ) ;
let args = cmd_values . collect ( ) ;
2021-04-16 09:28:41 -04:00
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Install ( InstallFlags {
2021-04-16 09:28:41 -04:00
name ,
module_url ,
args ,
root ,
force ,
2021-09-03 19:33:35 -04:00
} ) ;
2020-01-08 14:59:53 -05:00
}
2023-09-15 20:42:09 -04:00
fn jupyter_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
let conn_file = matches . remove_one ::< PathBuf > ( " conn " ) ;
let kernel = matches . get_flag ( " kernel " ) ;
let install = matches . get_flag ( " install " ) ;
flags . subcommand = DenoSubcommand ::Jupyter ( JupyterFlags {
install ,
kernel ,
conn_file ,
} ) ;
}
2023-03-26 00:06:18 -04:00
fn uninstall_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2023-11-13 09:44:01 -05:00
let root = matches . remove_one ::< String > ( " root " ) ;
2021-09-30 11:38:07 -04:00
2023-03-26 00:06:18 -04:00
let name = matches . remove_one ::< String > ( " name " ) . unwrap ( ) ;
2021-09-30 11:38:07 -04:00
flags . subcommand = DenoSubcommand ::Uninstall ( UninstallFlags { name , root } ) ;
}
2023-03-26 00:06:18 -04:00
fn lsp_parse ( flags : & mut Flags , _matches : & mut ArgMatches ) {
2021-06-22 21:48:01 -04:00
flags . subcommand = DenoSubcommand ::Lsp ;
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-03-26 00:06:18 -04:00
fn lint_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-05-13 11:40:50 -04:00
config_args_parse ( flags , matches ) ;
2024-01-15 19:15:39 -05:00
let files = match matches . remove_many ::< String > ( " files " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2024-01-15 19:15:39 -05:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 09:28:41 -04:00
None = > vec! [ ] ,
} ;
2023-03-26 00:06:18 -04:00
let rules = matches . get_flag ( " rules " ) ;
2021-11-04 11:12:12 -04:00
let maybe_rules_tags = matches
2023-03-26 00:06:18 -04:00
. remove_many ::< String > ( " rules-tags " )
. map ( | f | f . collect ( ) ) ;
2021-11-04 11:12:12 -04:00
let maybe_rules_include = matches
2023-03-26 00:06:18 -04:00
. remove_many ::< String > ( " rules-include " )
. map ( | f | f . collect ( ) ) ;
2021-11-04 11:12:12 -04:00
let maybe_rules_exclude = matches
2023-03-26 00:06:18 -04:00
. remove_many ::< String > ( " rules-exclude " )
. map ( | f | f . collect ( ) ) ;
2021-11-04 11:12:12 -04:00
2023-03-26 00:06:18 -04:00
let json = matches . get_flag ( " json " ) ;
let compact = matches . get_flag ( " compact " ) ;
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : files ,
ignore ,
} ,
2021-04-16 09:28:41 -04:00
rules ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags ,
maybe_rules_include ,
maybe_rules_exclude ,
2021-04-16 09:28:41 -04:00
json ,
2022-09-28 12:47:48 -04:00
compact ,
2023-06-15 13:09:37 -04:00
watch : watch_arg_parse ( matches ) ,
2021-09-03 19:33:35 -04:00
} ) ;
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-03-26 00:06:18 -04:00
fn repl_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-12-07 14:21:18 -05:00
runtime_args_parse ( flags , matches , true , true ) ;
2022-01-14 11:38:17 -05:00
unsafely_ignore_certificate_errors_parse ( flags , matches ) ;
2022-04-20 08:16:37 -04:00
2023-03-26 00:06:18 -04:00
let eval_files = matches
. remove_many ::< String > ( " eval-file " )
. map ( | values | values . collect ( ) ) ;
2022-04-20 08:16:37 -04:00
2022-01-14 11:38:17 -05:00
handle_repl_flags (
flags ,
ReplFlags {
2022-04-20 08:16:37 -04:00
eval_files ,
2023-03-26 00:06:18 -04:00
eval : matches . remove_one ::< String > ( " eval " ) ,
2022-12-07 14:21:18 -05:00
is_default_command : false ,
2022-01-14 11:38:17 -05:00
} ,
) ;
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-08-12 22:04:17 -04:00
fn run_parse (
flags : & mut Flags ,
matches : & mut ArgMatches ,
app : Command ,
) -> clap ::error ::Result < ( ) > {
2021-04-16 09:28:41 -04:00
runtime_args_parse ( flags , matches , true , true ) ;
2023-08-12 22:04:17 -04:00
let mut script_arg =
matches . remove_many ::< String > ( " script_arg " ) . ok_or_else ( | | {
let mut app = app ;
let subcommand = & mut app . find_subcommand_mut ( " run " ) . unwrap ( ) ;
subcommand . error (
clap ::error ::ErrorKind ::MissingRequiredArgument ,
" [SCRIPT_ARG] may only be omitted with --v8-flags=--help " ,
)
} ) ? ;
2023-03-26 00:06:18 -04:00
let script = script_arg . next ( ) . unwrap ( ) ;
flags . argv . extend ( script_arg ) ;
2021-04-16 09:28:41 -04:00
2023-03-22 10:15:53 -04:00
ext_arg_parse ( flags , matches ) ;
2023-06-15 13:09:37 -04:00
flags . subcommand = DenoSubcommand ::Run ( RunFlags {
script ,
watch : watch_arg_parse_with_paths ( matches ) ,
} ) ;
2023-08-12 22:04:17 -04:00
Ok ( ( ) )
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-03-26 00:06:18 -04:00
fn task_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . config_flag = matches
. remove_one ::< String > ( " config " )
2023-04-26 13:07:15 -04:00
. map ( ConfigFlag ::Path )
. unwrap_or ( ConfigFlag ::Discover ) ;
2022-03-10 20:56:14 -05:00
2022-06-08 17:30:16 -04:00
let mut task_flags = TaskFlags {
2023-03-26 00:06:18 -04:00
cwd : matches . remove_one ::< String > ( " cwd " ) ,
2023-02-22 22:45:35 -05:00
task : None ,
2022-06-08 17:30:16 -04:00
} ;
2023-03-26 00:06:18 -04:00
if let Some ( ( task , mut matches ) ) = matches . remove_subcommand ( ) {
task_flags . task = Some ( task ) ;
2022-03-10 20:56:14 -05:00
2023-03-26 00:06:18 -04:00
flags . argv . extend (
matches
. remove_many ::< std ::ffi ::OsString > ( " " )
. into_iter ( )
. flatten ( )
. filter_map ( | arg | arg . into_string ( ) . ok ( ) ) ,
) ;
2022-03-10 20:56:14 -05:00
}
2022-06-08 17:30:16 -04:00
flags . subcommand = DenoSubcommand ::Task ( task_flags ) ;
2022-03-10 20:56:14 -05:00
}
2023-03-26 00:06:18 -04:00
fn test_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::Local ;
2021-04-16 09:28:41 -04:00
runtime_args_parse ( flags , matches , true , true ) ;
2022-02-26 08:49:50 -05:00
// NOTE: `deno test` always uses `--no-prompt`, tests shouldn't ever do
// interactive prompts, unless done by user code
flags . no_prompt = true ;
2021-04-16 09:28:41 -04:00
2024-01-15 19:15:39 -05:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 00:06:18 -04:00
Some ( f ) = > f . collect ( ) ,
2021-08-24 11:23:29 -04:00
None = > vec! [ ] ,
} ;
2023-03-26 00:06:18 -04:00
let no_run = matches . get_flag ( " no-run " ) ;
let trace_ops = matches . get_flag ( " trace-ops " ) ;
let doc = matches . get_flag ( " doc " ) ;
let allow_none = matches . get_flag ( " allow-none " ) ;
let filter = matches . remove_one ::< String > ( " filter " ) ;
2021-04-16 09:28:41 -04:00
2023-03-26 00:06:18 -04:00
let fail_fast = if matches . contains_id ( " fail-fast " ) {
Some (
matches
. remove_one ::< NonZeroUsize > ( " fail-fast " )
. unwrap_or_else ( | | NonZeroUsize ::new ( 1 ) . unwrap ( ) ) ,
)
2021-07-12 06:55:42 -04:00
} else {
None
} ;
2023-03-26 00:06:18 -04:00
let shuffle = if matches . contains_id ( " shuffle " ) {
Some (
matches
. remove_one ::< u64 > ( " shuffle " )
. unwrap_or_else ( rand ::random ) ,
)
2021-07-05 21:20:33 -04:00
} else {
None
} ;
2021-05-10 02:06:13 -04:00
2023-03-26 00:06:18 -04:00
if let Some ( script_arg ) = matches . remove_many ::< String > ( " script_arg " ) {
flags . argv . extend ( script_arg ) ;
2021-04-16 09:28:41 -04:00
}
2023-03-26 00:06:18 -04:00
let concurrent_jobs = if matches . get_flag ( " parallel " ) {
2022-07-20 17:36:54 -04:00
if let Ok ( value ) = env ::var ( " DENO_JOBS " ) {
2023-01-07 15:22:09 -05:00
value . parse ::< NonZeroUsize > ( ) . ok ( )
2021-04-28 14:17:04 -04:00
} else {
2023-01-07 15:22:09 -05:00
std ::thread ::available_parallelism ( ) . ok ( )
2021-04-28 14:17:04 -04:00
}
2023-03-26 00:06:18 -04:00
} else if matches . contains_id ( " jobs " ) {
2022-12-09 10:54:24 -05:00
// We can't change this to use the log crate because its not configured
// yet at this point since the flags haven't been parsed. This flag is
// deprecated though so it's not worth changing the code to use the log
// crate here and this is only done for testing anyway.
eprintln! (
2022-07-20 17:36:54 -04:00
" {} " ,
crate ::colors ::yellow ( " Warning: --jobs flag is deprecated. Use the --parallel flag with possibly the 'DENO_JOBS' environment variable. " ) ,
) ;
2023-03-26 00:06:18 -04:00
if let Some ( value ) = matches . remove_one ::< NonZeroUsize > ( " jobs " ) {
Some ( value )
2022-07-20 17:36:54 -04:00
} else {
2023-01-07 15:22:09 -05:00
std ::thread ::available_parallelism ( ) . ok ( )
2022-07-20 17:36:54 -04:00
}
2021-04-28 14:17:04 -04:00
} else {
2023-01-07 15:22:09 -05:00
None
2021-04-28 14:17:04 -04:00
} ;
2024-01-15 19:15:39 -05:00
let include = if let Some ( files ) = matches . remove_many ::< String > ( " files " ) {
2023-03-26 00:06:18 -04:00
files . collect ( )
2021-04-16 09:28:41 -04:00
} else {
2022-07-18 15:12:19 -04:00
Vec ::new ( )
2021-04-16 09:28:41 -04:00
} ;
2023-08-02 22:05:34 -04:00
let junit_path = matches . remove_one ::< String > ( " junit-path " ) ;
let reporter =
if let Some ( reporter ) = matches . remove_one ::< String > ( " reporter " ) {
match reporter . as_str ( ) {
" pretty " = > TestReporterConfig ::Pretty ,
" junit " = > TestReporterConfig ::Junit ,
" dot " = > TestReporterConfig ::Dot ,
2023-08-25 19:19:23 -04:00
" tap " = > TestReporterConfig ::Tap ,
2023-08-02 22:05:34 -04:00
_ = > unreachable! ( ) ,
}
} else {
TestReporterConfig ::Pretty
} ;
2023-08-25 19:19:23 -04:00
if matches! ( reporter , TestReporterConfig ::Dot | TestReporterConfig ::Tap ) {
2023-08-02 12:38:10 -04:00
flags . log_level = Some ( Level ::Error ) ;
}
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Test ( TestFlags {
2021-04-16 09:28:41 -04:00
no_run ,
2021-05-10 19:54:39 -04:00
doc ,
2023-06-15 13:09:37 -04:00
coverage_dir : matches . remove_one ::< String > ( " coverage " ) ,
2021-04-16 09:28:41 -04:00
fail_fast ,
2023-01-07 15:22:09 -05:00
files : FileFlags { include , ignore } ,
2021-04-16 09:28:41 -04:00
filter ,
2021-07-05 21:20:33 -04:00
shuffle ,
2021-04-16 09:28:41 -04:00
allow_none ,
2021-04-28 14:17:04 -04:00
concurrent_jobs ,
2022-02-25 10:14:46 -05:00
trace_ops ,
2023-06-15 13:09:37 -04:00
watch : watch_arg_parse ( matches ) ,
2023-08-02 12:38:10 -04:00
reporter ,
2023-08-02 22:05:34 -04:00
junit_path ,
2021-09-03 19:33:35 -04:00
} ) ;
2020-02-17 11:59:51 -05:00
}
2020-04-03 13:40:11 -04:00
2023-03-26 00:06:18 -04:00
fn types_parse ( flags : & mut Flags , _matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
flags . subcommand = DenoSubcommand ::Types ;
2020-02-17 11:59:51 -05:00
}
2023-03-26 00:06:18 -04:00
fn upgrade_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 09:28:41 -04:00
ca_file_arg_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
let dry_run = matches . get_flag ( " dry-run " ) ;
let force = matches . get_flag ( " force " ) ;
let canary = matches . get_flag ( " canary " ) ;
let version = matches . remove_one ::< String > ( " version " ) ;
let output = matches . remove_one ::< PathBuf > ( " output " ) ;
2021-09-03 19:33:35 -04:00
flags . subcommand = DenoSubcommand ::Upgrade ( UpgradeFlags {
2021-04-16 09:28:41 -04:00
dry_run ,
force ,
canary ,
version ,
output ,
2021-09-03 19:33:35 -04:00
} ) ;
2021-01-07 13:06:08 -05:00
}
2023-03-26 00:06:18 -04:00
fn vendor_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-02-16 13:14:19 -05:00
ca_file_arg_parse ( flags , matches ) ;
2022-05-13 11:40:50 -04:00
config_args_parse ( flags , matches ) ;
2022-02-16 13:14:19 -05:00
import_map_arg_parse ( flags , matches ) ;
lock_arg_parse ( flags , matches ) ;
2023-08-06 21:56:56 -04:00
node_modules_and_vendor_dir_arg_parse ( flags , matches ) ;
2022-02-16 13:14:19 -05:00
reload_arg_parse ( flags , matches ) ;
flags . subcommand = DenoSubcommand ::Vendor ( VendorFlags {
specifiers : matches
2023-03-26 00:06:18 -04:00
. remove_many ::< String > ( " specifiers " )
. map ( | p | p . collect ( ) )
2022-02-16 13:14:19 -05:00
. unwrap_or_default ( ) ,
2023-03-26 00:06:18 -04:00
output_path : matches . remove_one ::< PathBuf > ( " output " ) ,
force : matches . get_flag ( " force " ) ,
2022-02-16 13:14:19 -05:00
} ) ;
}
2023-11-23 18:38:07 -05:00
fn publish_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . subcommand = DenoSubcommand ::Publish ( PublishFlags {
token : matches . remove_one ( " token " ) ,
2024-01-11 16:17:03 -05:00
dry_run : matches . get_flag ( " dry-run " ) ,
2023-11-23 18:38:07 -05:00
} ) ;
}
2023-03-26 00:06:18 -04:00
fn compile_args_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2023-03-13 17:04:00 -04:00
compile_args_without_check_parse ( flags , matches ) ;
2021-04-16 09:28:41 -04:00
no_check_arg_parse ( flags , matches ) ;
2022-06-13 17:13:16 -04:00
check_arg_parse ( flags , matches ) ;
2021-01-07 13:06:08 -05:00
}
2023-03-13 17:04:00 -04:00
fn compile_args_without_check_parse (
2022-04-10 19:12:51 -04:00
flags : & mut Flags ,
2023-03-26 00:06:18 -04:00
matches : & mut ArgMatches ,
2022-04-10 19:12:51 -04:00
) {
import_map_arg_parse ( flags , matches ) ;
no_remote_arg_parse ( flags , matches ) ;
2022-09-07 09:33:51 -04:00
no_npm_arg_parse ( flags , matches ) ;
2023-08-06 21:56:56 -04:00
node_modules_and_vendor_dir_arg_parse ( flags , matches ) ;
2022-05-13 11:40:50 -04:00
config_args_parse ( flags , matches ) ;
2022-04-10 19:12:51 -04:00
reload_arg_parse ( flags , matches ) ;
lock_args_parse ( flags , matches ) ;
ca_file_arg_parse ( flags , matches ) ;
}
2023-03-26 00:06:18 -04:00
fn permission_args_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-01-14 11:38:17 -05:00
unsafely_ignore_certificate_errors_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
if let Some ( read_wl ) = matches . remove_many ::< PathBuf > ( " allow-read " ) {
flags . allow_read = Some ( read_wl . collect ( ) ) ;
2021-04-16 09:28:41 -04:00
}
2023-08-03 07:19:19 -04:00
if let Some ( read_wl ) = matches . remove_many ::< PathBuf > ( " deny-read " ) {
flags . deny_read = Some ( read_wl . collect ( ) ) ;
}
2023-03-26 00:06:18 -04:00
if let Some ( write_wl ) = matches . remove_many ::< PathBuf > ( " allow-write " ) {
flags . allow_write = Some ( write_wl . collect ( ) ) ;
2021-04-16 09:28:41 -04:00
}
2023-08-03 07:19:19 -04:00
if let Some ( write_wl ) = matches . remove_many ::< PathBuf > ( " deny-write " ) {
flags . deny_write = Some ( write_wl . collect ( ) ) ;
}
2023-03-26 00:06:18 -04:00
if let Some ( net_wl ) = matches . remove_many ::< String > ( " allow-net " ) {
2023-08-03 07:19:19 -04:00
let net_allowlist = flags_net ::parse ( net_wl . collect ( ) ) . unwrap ( ) ;
2021-04-16 09:28:41 -04:00
flags . allow_net = Some ( net_allowlist ) ;
2021-08-09 10:53:21 -04:00
}
2023-08-03 07:19:19 -04:00
if let Some ( net_wl ) = matches . remove_many ::< String > ( " deny-net " ) {
let net_denylist = flags_net ::parse ( net_wl . collect ( ) ) . unwrap ( ) ;
flags . deny_net = Some ( net_denylist ) ;
}
2023-03-26 00:06:18 -04:00
if let Some ( env_wl ) = matches . remove_many ::< String > ( " allow-env " ) {
flags . allow_env = Some ( env_wl . collect ( ) ) ;
2021-04-16 09:28:41 -04:00
debug! ( " env allowlist: {:#?} " , & flags . allow_env ) ;
}
2023-08-03 07:19:19 -04:00
if let Some ( env_wl ) = matches . remove_many ::< String > ( " deny-env " ) {
flags . deny_env = Some ( env_wl . collect ( ) ) ;
debug! ( " env denylist: {:#?} " , & flags . deny_env ) ;
}
2023-03-26 00:06:18 -04:00
if let Some ( run_wl ) = matches . remove_many ::< String > ( " allow-run " ) {
flags . allow_run = Some ( run_wl . collect ( ) ) ;
2021-04-16 09:28:41 -04:00
debug! ( " run allowlist: {:#?} " , & flags . allow_run ) ;
}
2023-08-03 07:19:19 -04:00
if let Some ( run_wl ) = matches . remove_many ::< String > ( " deny-run " ) {
flags . deny_run = Some ( run_wl . collect ( ) ) ;
debug! ( " run denylist: {:#?} " , & flags . deny_run ) ;
}
2023-03-26 00:06:18 -04:00
if let Some ( sys_wl ) = matches . remove_many ::< String > ( " allow-sys " ) {
flags . allow_sys = Some ( sys_wl . collect ( ) ) ;
2022-09-28 08:46:50 -04:00
debug! ( " sys info allowlist: {:#?} " , & flags . allow_sys ) ;
}
2023-08-03 07:19:19 -04:00
if let Some ( sys_wl ) = matches . remove_many ::< String > ( " deny-sys " ) {
flags . deny_sys = Some ( sys_wl . collect ( ) ) ;
debug! ( " sys info denylist: {:#?} " , & flags . deny_sys ) ;
}
2023-03-26 00:06:18 -04:00
if let Some ( ffi_wl ) = matches . remove_many ::< PathBuf > ( " allow-ffi " ) {
flags . allow_ffi = Some ( ffi_wl . collect ( ) ) ;
2021-08-06 17:28:10 -04:00
debug! ( " ffi allowlist: {:#?} " , & flags . allow_ffi ) ;
2021-04-16 09:28:41 -04:00
}
2021-08-06 17:28:10 -04:00
2023-08-03 07:19:19 -04:00
if let Some ( ffi_wl ) = matches . remove_many ::< PathBuf > ( " deny-ffi " ) {
flags . deny_ffi = Some ( ffi_wl . collect ( ) ) ;
debug! ( " ffi denylist: {:#?} " , & flags . deny_ffi ) ;
}
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " allow-hrtime " ) {
2021-04-16 09:28:41 -04:00
flags . allow_hrtime = true ;
}
2023-08-03 07:19:19 -04:00
if matches . get_flag ( " deny-hrtime " ) {
flags . deny_hrtime = true ;
}
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " allow-all " ) {
2022-01-10 09:22:03 -05:00
flags . allow_all = true ;
2021-04-16 09:28:41 -04:00
flags . allow_read = Some ( vec! [ ] ) ;
flags . allow_env = Some ( vec! [ ] ) ;
flags . allow_net = Some ( vec! [ ] ) ;
flags . allow_run = Some ( vec! [ ] ) ;
flags . allow_write = Some ( vec! [ ] ) ;
2022-09-28 08:46:50 -04:00
flags . allow_sys = Some ( vec! [ ] ) ;
2021-08-06 17:28:10 -04:00
flags . allow_ffi = Some ( vec! [ ] ) ;
2021-04-16 09:28:41 -04:00
flags . allow_hrtime = true ;
}
2023-08-03 07:19:19 -04:00
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " no-prompt " ) {
2022-02-12 22:13:21 -05:00
flags . no_prompt = true ;
2021-04-16 09:28:41 -04:00
}
2020-03-27 16:09:51 -04:00
}
2023-11-10 12:41:24 -05:00
2022-01-14 11:38:17 -05:00
fn unsafely_ignore_certificate_errors_parse (
2021-12-10 09:47:55 -05:00
flags : & mut Flags ,
2023-03-26 00:06:18 -04:00
matches : & mut ArgMatches ,
2021-12-10 09:47:55 -05:00
) {
2023-03-26 00:06:18 -04:00
if let Some ( ic_wl ) =
matches . remove_many ::< String > ( " unsafely-ignore-certificate-errors " )
{
2023-08-03 07:19:19 -04:00
let ic_allowlist = flags_net ::parse ( ic_wl . collect ( ) ) . unwrap ( ) ;
2021-12-10 09:47:55 -05:00
flags . unsafely_ignore_certificate_errors = Some ( ic_allowlist ) ;
}
}
2023-03-13 17:04:00 -04:00
2021-04-16 09:28:41 -04:00
fn runtime_args_parse (
flags : & mut Flags ,
2023-03-26 00:06:18 -04:00
matches : & mut ArgMatches ,
2021-04-16 09:28:41 -04:00
include_perms : bool ,
include_inspector : bool ,
) {
compile_args_parse ( flags , matches ) ;
cached_only_arg_parse ( flags , matches ) ;
if include_perms {
permission_args_parse ( flags , matches ) ;
}
if include_inspector {
inspect_arg_parse ( flags , matches ) ;
2020-04-03 13:40:11 -04:00
}
2021-04-16 09:28:41 -04:00
location_arg_parse ( flags , matches ) ;
v8_flags_arg_parse ( flags , matches ) ;
seed_arg_parse ( flags , matches ) ;
2021-07-23 10:31:16 -04:00
enable_testing_features_arg_parse ( flags , matches ) ;
2023-11-01 11:21:13 -04:00
env_file_arg_parse ( flags , matches ) ;
2023-11-10 12:41:24 -05:00
strace_ops_parse ( flags , matches ) ;
2020-04-03 13:40:11 -04:00
}
2023-03-26 00:06:18 -04:00
fn inspect_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2020-04-03 13:40:11 -04:00
let default = | | " 127.0.0.1:9229 " . parse ::< SocketAddr > ( ) . unwrap ( ) ;
2023-03-26 00:06:18 -04:00
flags . inspect = if matches . contains_id ( " inspect " ) {
Some (
matches
. remove_one ::< SocketAddr > ( " inspect " )
. unwrap_or_else ( default ) ,
)
2020-03-27 16:09:51 -04:00
} else {
None
} ;
2023-03-26 00:06:18 -04:00
flags . inspect_brk = if matches . contains_id ( " inspect-brk " ) {
Some (
matches
. remove_one ::< SocketAddr > ( " inspect-brk " )
. unwrap_or_else ( default ) ,
)
2020-03-27 16:09:51 -04:00
} else {
None
} ;
2023-03-26 00:06:18 -04:00
flags . inspect_wait = if matches . contains_id ( " inspect-wait " ) {
Some (
matches
. remove_one ::< SocketAddr > ( " inspect-wait " )
. unwrap_or_else ( default ) ,
)
2022-12-12 09:33:30 -05:00
} else {
None
} ;
2020-03-27 16:09:51 -04:00
}
2023-03-26 00:06:18 -04:00
fn import_map_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . import_map_path = matches . remove_one ::< String > ( " import-map " ) ;
2019-11-26 11:06:32 -05:00
}
2019-08-15 10:11:52 -04:00
2023-11-01 11:21:13 -04:00
fn env_file_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . env_file = matches . remove_one ::< String > ( " env " ) ;
}
2023-03-26 00:06:18 -04:00
fn reload_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( cache_bl ) = matches . remove_many ::< String > ( " reload " ) {
let raw_cache_blocklist : Vec < String > = cache_bl . collect ( ) ;
2020-06-13 13:09:39 -04:00
if raw_cache_blocklist . is_empty ( ) {
2020-05-16 09:41:32 -04:00
flags . reload = true ;
} else {
2020-06-13 13:09:39 -04:00
flags . cache_blocklist = resolve_urls ( raw_cache_blocklist ) ;
debug! ( " cache blocklist: {:#?} " , & flags . cache_blocklist ) ;
2019-11-26 11:06:32 -05:00
flags . reload = false ;
2019-05-03 17:15:16 -04:00
}
2019-11-26 11:06:32 -05:00
}
}
2019-10-04 09:02:36 -04:00
2023-03-26 00:06:18 -04:00
fn ca_file_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . ca_data = matches . remove_one ::< String > ( " cert " ) . map ( CaData ::File ) ;
2019-11-26 11:06:32 -05:00
}
2019-10-04 09:02:36 -04:00
2021-07-23 10:31:16 -04:00
fn enable_testing_features_arg_parse (
flags : & mut Flags ,
2023-03-26 00:06:18 -04:00
matches : & mut ArgMatches ,
2021-07-23 10:31:16 -04:00
) {
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " enable-testing-features-do-not-use " ) {
2021-07-23 10:31:16 -04:00
flags . enable_testing_features = true
}
}
2023-11-10 12:41:24 -05:00
fn strace_ops_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( patterns ) = matches . remove_many ::< String > ( " strace-ops " ) {
flags . strace_ops = Some ( patterns . collect ( ) ) ;
}
}
2023-03-26 00:06:18 -04:00
fn cached_only_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . get_flag ( " cached-only " ) {
2021-04-16 09:28:41 -04:00
flags . cached_only = true ;
}
2019-11-26 11:06:32 -05:00
}
2019-10-04 09:02:36 -04:00
2023-03-26 00:06:18 -04:00
fn ext_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . ext = matches . remove_one ::< String > ( " ext " ) ;
2023-03-22 10:15:53 -04:00
}
2023-03-26 00:06:18 -04:00
fn location_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . location = matches . remove_one ::< Url > ( " location " ) ;
2019-11-26 23:25:14 -05:00
}
2023-03-26 00:06:18 -04:00
fn v8_flags_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( v8_flags ) = matches . remove_many ::< String > ( " v8-flags " ) {
flags . v8_flags = v8_flags . collect ( ) ;
2019-11-26 23:25:14 -05:00
}
}
2023-03-26 00:06:18 -04:00
fn seed_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( seed ) = matches . remove_one ::< u64 > ( " seed " ) {
2020-09-18 13:09:11 -04:00
flags . seed = Some ( seed ) ;
2023-01-27 10:43:16 -05:00
flags . v8_flags . push ( format! ( " --random-seed= {seed} " ) ) ;
2020-09-18 13:09:11 -04:00
}
}
2023-03-26 00:06:18 -04:00
fn no_check_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( cache_type ) = matches . get_one ::< String > ( " no-check " ) {
match cache_type . as_str ( ) {
2022-04-10 19:12:51 -04:00
" remote " = > flags . type_check_mode = TypeCheckMode ::Local ,
2021-11-29 17:23:30 -05:00
_ = > debug! (
" invalid value for 'no-check' of '{}' using default " ,
cache_type
) ,
}
2023-03-26 00:06:18 -04:00
} else if matches . contains_id ( " no-check " ) {
2022-04-10 19:12:51 -04:00
flags . type_check_mode = TypeCheckMode ::None ;
}
}
2023-03-26 00:06:18 -04:00
fn check_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( cache_type ) = matches . get_one ::< String > ( " check " ) {
match cache_type . as_str ( ) {
2022-06-13 17:13:16 -04:00
" all " = > flags . type_check_mode = TypeCheckMode ::All ,
2022-04-10 19:12:51 -04:00
_ = > debug! (
" invalid value for 'check' of '{}' using default " ,
cache_type
) ,
}
2023-03-26 00:06:18 -04:00
} else if matches . contains_id ( " check " ) {
2022-06-13 17:13:16 -04:00
flags . type_check_mode = TypeCheckMode ::Local ;
2020-07-08 05:26:39 -04:00
}
}
2023-03-26 00:06:18 -04:00
fn lock_args_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-02-16 13:14:19 -05:00
lock_arg_parse ( flags , matches ) ;
2023-03-13 17:04:00 -04:00
no_lock_arg_parse ( flags , matches ) ;
2023-03-26 00:06:18 -04:00
if matches . get_flag ( " lock-write " ) {
2022-02-16 13:14:19 -05:00
flags . lock_write = true ;
}
}
2023-03-26 00:06:18 -04:00
fn lock_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . contains_id ( " lock " ) {
let lockfile = matches
. remove_one ::< PathBuf > ( " lock " )
. unwrap_or_else ( | | PathBuf ::from ( " ./deno.lock " ) ) ;
flags . lock = Some ( lockfile ) ;
2021-04-16 09:28:41 -04:00
}
}
2023-03-26 00:06:18 -04:00
fn no_lock_arg_parse ( flags : & mut Flags , matches : & ArgMatches ) {
if matches . get_flag ( " no-lock " ) {
2023-03-13 17:04:00 -04:00
flags . no_lock = true ;
}
}
2023-03-26 00:06:18 -04:00
fn config_args_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . config_flag = if matches . get_flag ( " no-config " ) {
2022-05-13 11:40:50 -04:00
ConfigFlag ::Disabled
2023-03-26 00:06:18 -04:00
} else if let Some ( config ) = matches . remove_one ::< String > ( " config " ) {
ConfigFlag ::Path ( config )
2022-05-13 11:40:50 -04:00
} else {
ConfigFlag ::Discover
} ;
2019-12-03 17:48:53 -05:00
}
2023-03-26 00:06:18 -04:00
fn no_remote_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . get_flag ( " no-remote " ) {
2019-12-03 17:48:53 -05:00
flags . no_remote = true ;
}
}
2023-03-26 00:06:18 -04:00
fn no_npm_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . get_flag ( " no-npm " ) {
2022-09-07 09:33:51 -04:00
flags . no_npm = true ;
}
}
2023-08-06 21:56:56 -04:00
fn node_modules_and_vendor_dir_arg_parse (
2023-08-01 20:49:09 -04:00
flags : & mut Flags ,
matches : & mut ArgMatches ,
) {
2023-03-26 00:06:18 -04:00
flags . node_modules_dir = matches . remove_one ::< bool > ( " node-modules-dir " ) ;
2023-08-06 21:56:56 -04:00
flags . vendor = matches . remove_one ::< bool > ( " vendor " ) ;
2020-01-30 18:42:39 -05:00
}
2023-03-26 00:06:18 -04:00
fn reload_arg_validate ( urlstr : & str ) -> Result < String , String > {
2022-09-06 12:30:42 -04:00
if urlstr . is_empty ( ) {
return Err ( String ::from ( " Missing url. Check for extra commas. " ) ) ;
}
match Url ::from_str ( urlstr ) {
2023-03-26 00:06:18 -04:00
Ok ( _ ) = > Ok ( urlstr . to_string ( ) ) ,
2022-09-06 12:30:42 -04:00
Err ( e ) = > Err ( e . to_string ( ) ) ,
}
}
2023-06-15 13:09:37 -04:00
fn watch_arg_parse ( matches : & mut ArgMatches ) -> Option < WatchFlags > {
if matches . get_flag ( " watch " ) {
Some ( WatchFlags {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
no_clear_screen : matches . get_flag ( " no-clear-screen " ) ,
} )
} else {
None
2021-12-15 16:04:43 -05:00
}
2023-06-15 13:09:37 -04:00
}
2022-01-31 11:39:39 -05:00
2023-06-15 13:09:37 -04:00
fn watch_arg_parse_with_paths (
matches : & mut ArgMatches ,
) -> Option < WatchFlagsWithPaths > {
2023-10-30 20:25:58 -04:00
if let Some ( paths ) = matches . remove_many ::< PathBuf > ( " watch " ) {
return Some ( WatchFlagsWithPaths {
paths : paths . collect ( ) ,
hmr : false ,
no_clear_screen : matches . get_flag ( " no-clear-screen " ) ,
} ) ;
}
2023-06-15 13:09:37 -04:00
matches
2023-10-30 20:25:58 -04:00
. remove_many ::< PathBuf > ( " hmr " )
. map ( | paths | WatchFlagsWithPaths {
paths : paths . collect ( ) ,
hmr : true ,
2023-06-15 13:09:37 -04:00
no_clear_screen : matches . get_flag ( " no-clear-screen " ) ,
} )
2021-12-15 16:04:43 -05:00
}
2019-11-26 11:06:32 -05:00
// TODO(ry) move this to utility module and add test.
/// Strips fragment part of URL. Panics on bad URL.
pub fn resolve_urls ( urls : Vec < String > ) -> Vec < String > {
let mut out : Vec < String > = vec! [ ] ;
for urlstr in urls . iter ( ) {
2020-11-12 17:17:31 -05:00
if let Ok ( mut url ) = Url ::from_str ( urlstr ) {
url . set_fragment ( None ) ;
let mut full_url = String ::from ( url . as_str ( ) ) ;
if full_url . len ( ) > 1 & & full_url . ends_with ( '/' ) {
full_url . pop ( ) ;
}
out . push ( full_url ) ;
} else {
2023-01-27 10:43:16 -05:00
panic! ( " Bad Url: {urlstr} " ) ;
2019-06-05 13:44:46 -04:00
}
2019-11-26 11:06:32 -05:00
}
out
2019-04-29 19:43:06 -04:00
}
2019-11-26 11:06:32 -05:00
#[ cfg(test) ]
mod tests {
use super ::* ;
2022-04-27 15:43:36 -04:00
use pretty_assertions ::assert_eq ;
2019-11-26 11:06:32 -05:00
2020-12-06 12:19:21 -05:00
/// Creates vector of strings, Vec<String>
macro_rules ! svec {
2022-02-16 13:14:19 -05:00
( $( $x :expr ) , * $(, ) ? ) = > ( vec! [ $( $x . to_string ( ) ) , * ] ) ;
}
2020-12-06 12:19:21 -05:00
2020-09-20 07:45:00 -04:00
#[ test ]
fn global_flags ( ) {
#[ rustfmt::skip ]
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " --unstable " , " --log-level " , " debug " , " --quiet " , " run " , " script.ts " ] ) ;
2023-01-07 15:22:09 -05:00
2020-09-20 07:45:00 -04:00
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2020-09-20 07:45:00 -04:00
unstable : true ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
#[ rustfmt::skip ]
2021-01-07 13:06:08 -05:00
let r2 = flags_from_vec ( svec! [ " deno " , " run " , " --unstable " , " --log-level " , " debug " , " --quiet " , " script.ts " ] ) ;
2020-09-20 07:45:00 -04:00
let flags2 = r2 . unwrap ( ) ;
assert_eq! ( flags2 , flags ) ;
}
2020-03-23 11:37:24 -04:00
#[ test ]
fn upgrade ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " upgrade " , " --dry-run " , " --force " ] ) ;
2020-03-23 11:37:24 -04:00
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Upgrade ( UpgradeFlags {
2020-03-23 11:37:24 -04:00
force : true ,
dry_run : true ,
2020-11-29 14:00:35 -05:00
canary : false ,
2020-07-05 23:58:23 -04:00
version : None ,
2020-07-06 18:21:26 -04:00
output : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-03-23 11:37:24 -04:00
.. Flags ::default ( )
}
) ;
}
2019-11-26 11:06:32 -05:00
#[ test ]
fn version ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " --version " ] ) ;
2023-03-26 00:06:18 -04:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::DisplayVersion
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " -V " ] ) ;
2023-03-26 00:06:18 -04:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::DisplayVersion
) ;
2019-04-21 11:34:18 -04:00
}
2018-08-24 15:26:40 -04:00
2019-04-21 11:34:18 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn run_reload ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " -r " , " script.ts " ] ) ;
2019-11-26 11:06:32 -05:00
let flags = r . unwrap ( ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
flags ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2019-04-21 11:34:18 -04:00
reload : true ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
) ;
}
2018-10-11 17:23:22 -04:00
2020-09-11 12:19:49 -04:00
#[ test ]
fn run_watch ( ) {
2021-04-27 06:44:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --watch " , " script.ts " ] ) ;
2020-09-11 12:19:49 -04:00
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-09-11 12:19:49 -04:00
script : " script.ts " . to_string ( ) ,
2023-06-15 13:09:37 -04:00
watch : Some ( WatchFlagsWithPaths {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
paths : vec ! [ ] ,
no_clear_screen : false ,
} ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2021-12-15 16:04:43 -05:00
.. Flags ::default ( )
}
) ;
2023-10-30 20:25:58 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --watch " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : false ,
paths : vec ! [ ] ,
no_clear_screen : true ,
} ) ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --unstable-hmr " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : true ,
paths : vec ! [ ] ,
no_clear_screen : true ,
} ) ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --unstable-hmr=foo.txt " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : true ,
paths : vec ! [ PathBuf ::from ( " foo.txt " ) ] ,
no_clear_screen : true ,
} ) ,
} ) ,
.. Flags ::default ( )
}
) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --hmr " , " --watch " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
2021-12-15 16:04:43 -05:00
}
#[ test ]
fn run_watch_with_external ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --watch=file1,file2 " , " script.ts " ] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
2023-06-15 13:09:37 -04:00
watch : Some ( WatchFlagsWithPaths {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
paths : vec ! [ PathBuf ::from ( " file1 " ) , PathBuf ::from ( " file2 " ) ] ,
no_clear_screen : false ,
} ) ,
2021-12-15 16:04:43 -05:00
} ) ,
2020-09-11 12:19:49 -04:00
.. Flags ::default ( )
}
) ;
}
2022-01-31 11:39:39 -05:00
#[ test ]
fn run_watch_with_no_clear_screen ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --watch " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
2023-06-15 13:09:37 -04:00
watch : Some ( WatchFlagsWithPaths {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
paths : vec ! [ ] ,
no_clear_screen : true ,
2023-12-06 16:36:06 -05:00
} ) ,
2022-01-31 11:39:39 -05:00
} ) ,
.. Flags ::default ( )
}
) ;
}
2019-04-21 11:34:18 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn run_reload_allow_write ( ) {
2021-01-07 13:06:08 -05:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " -r " , " --allow-write " , " script.ts " ] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2019-04-21 11:34:18 -04:00
reload : true ,
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
) ;
}
2018-10-15 14:26:22 -04:00
2019-04-21 11:34:18 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn run_v8_flags ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --v8-flags=--help " ] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default ( " _ " . to_string ( ) ) ) ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --help " ] ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
) ;
2019-01-09 11:59:54 -05:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-05-03 17:15:16 -04:00
" deno " ,
" run " ,
2019-11-26 11:06:32 -05:00
" --v8-flags=--expose-gc,--gc-stats=1 " ,
2019-05-03 17:15:16 -04:00
" script.ts "
] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --expose-gc " , " --gc-stats=1 " ] ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
) ;
2023-08-12 22:04:17 -04:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --v8-flags=--expose-gc " ] ) ;
assert! ( r
. unwrap_err ( )
. to_string ( )
. contains ( " [SCRIPT_ARG] may only be omitted with --v8-flags=--help " ) ) ;
2019-04-21 11:34:18 -04:00
}
2022-11-23 22:00:31 -05:00
#[ test ]
fn has_permission ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-read " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission ( ) , true ) ;
2023-08-03 07:19:19 -04:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-read " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission ( ) , true ) ;
2022-11-23 22:00:31 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission ( ) , false ) ;
}
#[ test ]
fn has_permission_in_argv ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " , " --allow-read " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission_in_argv ( ) , true ) ;
2023-08-03 07:19:19 -04:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " , " --deny-read " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission_in_argv ( ) , true ) ;
2022-11-23 22:00:31 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission_in_argv ( ) , false ) ;
}
2019-04-21 11:34:18 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn script_args ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-05-03 17:15:16 -04:00
" deno " ,
" run " ,
" --allow-net " ,
" gist.ts " ,
" --title " ,
" X "
] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2020-02-04 14:24:33 -05:00
argv : svec ! [ " --title " , " X " ] ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
2019-04-29 19:43:06 -04:00
) ;
2019-04-21 11:34:18 -04:00
}
#[ test ]
2019-11-26 11:06:32 -05:00
fn allow_all ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-all " , " gist.ts " ] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2022-01-10 09:22:03 -05:00
allow_all : true ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2019-05-23 12:28:29 -04:00
allow_hrtime : true ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
2019-04-29 19:43:06 -04:00
) ;
2019-04-21 11:34:18 -04:00
}
#[ test ]
2019-11-26 11:06:32 -05:00
fn allow_read ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-read " , " gist.ts " ] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
2019-04-29 19:43:06 -04:00
) ;
2019-04-21 11:34:18 -04:00
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_read ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-read " , " gist.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2023-08-03 07:19:19 -04:00
deny_read : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
2019-04-21 11:34:18 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn allow_hrtime ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-hrtime " , " gist.ts " ] ) ;
2019-04-21 11:34:18 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( ) ,
) ) ,
2019-05-23 12:28:29 -04:00
allow_hrtime : true ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
2019-04-29 19:43:06 -04:00
) ;
2019-04-21 11:34:18 -04:00
}
2019-04-08 16:22:40 -04:00
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_hrtime ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-hrtime " , " gist.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2019-04-21 11:34:18 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn double_hyphen ( ) {
2019-06-29 18:32:54 -04:00
// notice that flags passed after double dash will not
2020-02-26 05:52:15 -05:00
// be parsed to Flags but instead forwarded to
2019-04-21 11:34:18 -04:00
// script args as Deno.args
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-04-21 11:34:18 -04:00
" deno " ,
2019-05-03 17:15:16 -04:00
" run " ,
2019-04-21 11:34:18 -04:00
" --allow-write " ,
" script.ts " ,
2019-06-29 18:32:54 -04:00
" -- " ,
2019-04-21 11:34:18 -04:00
" -D " ,
" --allow-net "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-02-04 14:24:33 -05:00
argv : svec ! [ " -- " , " -D " , " --allow-net " ] ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-21 11:34:18 -04:00
}
2019-04-29 19:43:06 -04:00
) ;
}
#[ test ]
2019-11-26 11:06:32 -05:00
fn fmt ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " script_1.ts " , " script_2.ts " ] ) ;
2019-04-29 19:43:06 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-01-29 21:16:48 -05:00
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2020-01-29 21:16:48 -05:00
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " --check " ] ) ;
2020-01-29 21:16:48 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-01-29 21:16:48 -05:00
check : true ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-04-29 19:43:06 -04:00
}
) ;
2020-02-09 05:19:05 -05:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " ] ) ;
2020-02-09 05:19:05 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-02-09 05:19:05 -05:00
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2020-02-09 05:19:05 -05:00
}
) ;
2020-11-22 15:45:44 -05:00
2021-04-27 06:44:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " --watch " ] ) ;
2020-11-22 15:45:44 -05:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-11-22 15:45:44 -05:00
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2020-11-22 15:45:44 -05:00
.. Flags ::default ( )
}
) ;
2022-01-31 11:39:39 -05:00
let r =
flags_from_vec ( svec! [ " deno " , " fmt " , " --watch " , " --no-clear-screen " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2022-01-31 11:39:39 -05:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-06-15 13:09:37 -04:00
watch : Some ( WatchFlags {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
no_clear_screen : true ,
} )
2022-01-31 11:39:39 -05:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2022-01-31 11:39:39 -05:00
.. Flags ::default ( )
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-11-22 15:45:44 -05:00
" deno " ,
" fmt " ,
" --check " ,
" --watch " ,
" foo.ts " ,
" --ignore=bar.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-11-22 15:45:44 -05:00
check : true ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " foo.ts " . to_string ( ) ] ,
ignore : vec ! [ " bar.js " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2021-09-13 14:19:10 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " --config " , " deno.jsonc " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-13 14:19:10 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2021-09-13 14:19:10 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" fmt " ,
" --config " ,
" deno.jsonc " ,
" --watch " ,
" foo.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " foo.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 15:06:00 -05:00
no_semicolons : None ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2021-09-13 14:19:10 -04:00
} ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2020-11-22 15:45:44 -05:00
.. Flags ::default ( )
}
) ;
2021-09-13 16:06:45 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" fmt " ,
2023-02-11 12:39:56 -05:00
" --use-tabs " ,
" --line-width " ,
2021-09-13 16:06:45 -04:00
" 60 " ,
2023-02-11 12:39:56 -05:00
" --indent-width " ,
2021-09-13 16:06:45 -04:00
" 4 " ,
2023-02-11 12:39:56 -05:00
" --single-quote " ,
" --prose-wrap " ,
2023-01-24 15:07:00 -05:00
" never " ,
2023-02-11 12:39:56 -05:00
" --no-semicolons " ,
2021-09-13 16:06:45 -04:00
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 16:06:45 -04:00
use_tabs : Some ( true ) ,
line_width : Some ( NonZeroU32 ::new ( 60 ) . unwrap ( ) ) ,
indent_width : Some ( NonZeroU8 ::new ( 4 ) . unwrap ( ) ) ,
single_quote : Some ( true ) ,
prose_wrap : Some ( " never " . to_string ( ) ) ,
2023-01-25 15:06:00 -05:00
no_semicolons : Some ( true ) ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2023-01-25 15:06:00 -05:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2023-01-25 15:06:00 -05:00
.. Flags ::default ( )
}
) ;
// try providing =false to the booleans
let r = flags_from_vec ( svec! [
" deno " ,
" fmt " ,
2023-02-11 12:39:56 -05:00
" --use-tabs=false " ,
" --single-quote=false " ,
" --no-semicolons=false " ,
2023-01-25 15:06:00 -05:00
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
use_tabs : Some ( false ) ,
line_width : None ,
indent_width : None ,
single_quote : Some ( false ) ,
prose_wrap : None ,
no_semicolons : Some ( false ) ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-13 16:06:45 -04:00
} ) ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2021-09-13 16:06:45 -04:00
.. Flags ::default ( )
}
) ;
2019-04-29 19:43:06 -04:00
}
2020-06-10 17:29:48 -04:00
#[ test ]
fn lint ( ) {
2021-04-27 06:44:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " lint " , " script_1.ts " , " script_2.ts " ] ) ;
2020-06-10 17:29:48 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) , ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2020-06-12 10:42:12 -04:00
rules : false ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2020-08-13 11:30:46 -04:00
json : false ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-06-10 17:29:48 -04:00
.. Flags ::default ( )
}
) ;
2022-01-31 11:39:39 -05:00
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --watch " ,
" script_1.ts " ,
" script_2.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2022-01-31 11:39:39 -05:00
rules : false ,
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2022-01-31 11:39:39 -05:00
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --watch " ,
" --no-clear-screen " ,
" script_1.ts " ,
" script_2.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2022-01-31 11:39:39 -05:00
rules : false ,
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Some ( WatchFlags {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
no_clear_screen : true ,
} )
2022-01-31 11:39:39 -05:00
} ) ,
.. Flags ::default ( )
}
) ;
2021-04-27 06:44:36 -04:00
let r =
flags_from_vec ( svec! [ " deno " , " lint " , " --ignore=script_1.ts,script_2.ts " ] ) ;
2020-06-10 17:29:48 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
2024-01-15 19:15:39 -05:00
ignore : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
} ,
2020-06-12 10:42:12 -04:00
rules : false ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2020-08-13 11:30:46 -04:00
json : false ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-06-12 10:42:12 -04:00
.. Flags ::default ( )
}
) ;
2021-04-27 06:44:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " lint " , " --rules " ] ) ;
2020-06-12 10:42:12 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2020-08-12 09:47:44 -04:00
rules : true ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2021-09-03 11:01:58 -04:00
json : false ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2021-09-03 11:01:58 -04:00
.. Flags ::default ( )
}
) ;
2023-07-25 17:24:06 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --rules " ,
" --rules-tags=recommended "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
rules : true ,
maybe_rules_tags : Some ( svec! [ " recommended " ] ) ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
compact : false ,
watch : Default ::default ( ) ,
} ) ,
.. Flags ::default ( )
}
) ;
2021-09-03 11:01:58 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --rules-tags= " ,
" --rules-include=ban-untagged-todo,no-undef " ,
" --rules-exclude=no-const-assign "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-03 11:01:58 -04:00
rules : false ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags : Some ( svec! [ " " ] ) ,
maybe_rules_include : Some ( svec! [ " ban-untagged-todo " , " no-undef " ] ) ,
maybe_rules_exclude : Some ( svec! [ " no-const-assign " ] ) ,
2020-08-13 11:30:46 -04:00
json : false ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-08-13 11:30:46 -04:00
.. Flags ::default ( )
}
) ;
2021-04-27 06:44:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " lint " , " --json " , " script_1.ts " ] ) ;
2020-08-13 11:30:46 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2020-08-13 11:30:46 -04:00
rules : false ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2021-09-03 11:01:58 -04:00
json : true ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2021-09-03 11:01:58 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --config " ,
" Deno.jsonc " ,
" --json " ,
" script_1.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2021-09-03 11:01:58 -04:00
rules : false ,
2021-11-04 11:12:12 -04:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2020-08-13 11:30:46 -04:00
json : true ,
2022-09-28 12:47:48 -04:00
compact : false ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2022-09-28 12:47:48 -04:00
} ) ,
config_flag : ConfigFlag ::Path ( " Deno.jsonc " . to_string ( ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --config " ,
" Deno.jsonc " ,
" --compact " ,
" script_1.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " script_1.ts " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2022-09-28 12:47:48 -04:00
rules : false ,
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
compact : true ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " Deno.jsonc " . to_string ( ) ) ,
2020-06-10 17:29:48 -04:00
.. Flags ::default ( )
}
) ;
}
2019-04-29 19:43:06 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn types ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " types " ] ) ;
2019-11-26 11:06:32 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2019-11-26 11:06:32 -05:00
subcommand : DenoSubcommand ::Types ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-11-26 11:06:32 -05:00
}
) ;
2019-04-29 19:43:06 -04:00
}
#[ test ]
2020-04-07 11:24:47 -04:00
fn cache ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " cache " , " script.ts " ] ) ;
2019-11-26 11:06:32 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-02-04 14:24:33 -05:00
files : svec ! [ " script.ts " ] ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-11-26 11:06:32 -05:00
}
) ;
2019-04-29 19:43:06 -04:00
}
2022-04-10 19:12:51 -04:00
#[ test ]
fn check ( ) {
let r = flags_from_vec ( svec! [ " deno " , " check " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Check ( CheckFlags {
files : svec ! [ " script.ts " ] ,
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-04-10 19:12:51 -04:00
.. Flags ::default ( )
}
) ;
2022-12-07 13:33:26 -05:00
for all_flag in [ " --remote " , " --all " ] {
let r = flags_from_vec ( svec! [ " deno " , " check " , all_flag , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Check ( CheckFlags {
files : svec ! [ " script.ts " ] ,
} ) ,
type_check_mode : TypeCheckMode ::All ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" check " ,
all_flag ,
" --no-remote " ,
" script.ts "
] ) ;
2023-03-26 00:06:18 -04:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::ArgumentConflict
) ;
2022-12-07 13:33:26 -05:00
}
2022-04-10 19:12:51 -04:00
}
2019-04-29 19:43:06 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn info ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " script.ts " ] ) ;
2019-11-26 11:06:32 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 10:50:12 -04:00
json : false ,
file : Some ( " script.ts " . to_string ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-07-08 10:50:12 -04:00
.. Flags ::default ( )
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " --reload " , " script.ts " ] ) ;
2020-08-12 06:58:50 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-08-12 06:58:50 -04:00
json : false ,
file : Some ( " script.ts " . to_string ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-08-12 06:58:50 -04:00
reload : true ,
.. Flags ::default ( )
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " --json " , " script.ts " ] ) ;
2020-07-08 10:50:12 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 10:50:12 -04:00
json : true ,
2020-02-04 14:24:33 -05:00
file : Some ( " script.ts " . to_string ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-11-26 11:06:32 -05:00
}
) ;
2019-08-11 20:43:01 -04:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " info " ] ) ;
2019-11-26 11:06:32 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 10:50:12 -04:00
json : false ,
file : None
2021-09-03 19:33:35 -04:00
} ) ,
2020-07-08 10:50:12 -04:00
.. Flags ::default ( )
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " --json " ] ) ;
2020-07-08 10:50:12 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 10:50:12 -04:00
json : true ,
file : None
2021-09-03 19:33:35 -04:00
} ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-11-26 11:06:32 -05:00
}
) ;
2022-06-13 14:09:04 -04:00
2023-03-13 17:04:00 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" info " ,
" --no-npm " ,
" --no-remote " ,
" --config " ,
" tsconfig.json "
] ) ;
2022-06-13 14:09:04 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Info ( InfoFlags {
json : false ,
file : None
} ) ,
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2023-03-13 17:04:00 -04:00
no_npm : true ,
no_remote : true ,
2022-06-13 14:09:04 -04:00
.. Flags ::default ( )
}
) ;
2019-04-21 11:34:18 -04:00
}
2019-04-29 10:58:31 -04:00
2019-05-03 16:24:09 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn tsconfig ( ) {
2021-01-07 13:06:08 -05:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " -c " , " tsconfig.json " , " script.ts " ] ) ;
2019-05-03 17:15:16 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-05-03 17:15:16 -04:00
}
) ;
}
#[ test ]
2019-11-26 11:06:32 -05:00
fn eval ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " eval " , " 'console.log( \" hello \" )' " ] ) ;
2019-05-03 17:15:16 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 10:35:36 -04:00
print : false ,
2020-02-04 14:24:33 -05:00
code : " 'console.log( \" hello \" )' " . to_string ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2020-02-28 09:17:56 -05:00
allow_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2020-05-21 10:35:36 -04:00
#[ test ]
fn eval_p ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " eval " , " -p " , " 1+2 " ] ) ;
2020-05-21 10:35:36 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 10:35:36 -04:00
print : true ,
code : " 1+2 " . to_string ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2020-05-21 10:35:36 -04:00
allow_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2020-02-28 09:17:56 -05:00
#[ test ]
fn eval_typescript ( ) {
2021-01-07 13:06:08 -05:00
let r =
flags_from_vec ( svec! [ " deno " , " eval " , " -T " , " 'console.log( \" hello \" )' " ] ) ;
2020-02-28 09:17:56 -05:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 10:35:36 -04:00
print : false ,
2020-02-28 09:17:56 -05:00
code : " 'console.log( \" hello \" )' " . to_string ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2019-05-23 12:28:29 -04:00
allow_hrtime : true ,
2023-03-22 10:15:53 -04:00
ext : Some ( " ts " . to_string ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-05-03 17:15:16 -04:00
}
) ;
}
2020-01-26 09:49:34 -05:00
#[ test ]
2020-09-18 13:09:11 -04:00
fn eval_with_flags ( ) {
#[ rustfmt::skip ]
2023-11-01 11:21:13 -04:00
let r = flags_from_vec ( svec! [ " deno " , " eval " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --location " , " https:foo " , " --v8-flags=--help " , " --seed " , " 1 " , " --inspect=127.0.0.1:9229 " , " --env=.example.env " , " 42 " ] ) ;
2020-01-26 09:49:34 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 10:35:36 -04:00
print : false ,
2020-02-04 14:24:33 -05:00
code : " 42 " . to_string ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-09-18 13:09:11 -04:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2020-09-18 13:09:11 -04:00
reload : true ,
2020-10-19 15:19:20 -04:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-09-18 13:09:11 -04:00
lock_write : true ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2020-09-18 13:09:11 -04:00
cached_only : true ,
2021-01-07 13:06:08 -05:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
2020-09-18 13:09:11 -04:00
seed : Some ( 1 ) ,
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2020-01-26 09:49:34 -05:00
allow_hrtime : true ,
2023-11-01 11:21:13 -04:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2020-01-26 09:49:34 -05:00
}
) ;
}
2020-11-29 21:10:21 -05:00
#[ test ]
fn eval_args ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-11-29 21:10:21 -05:00
" deno " ,
" eval " ,
" console.log(Deno.args) " ,
" arg1 " ,
" arg2 "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-11-29 21:10:21 -05:00
print : false ,
code : " console.log(Deno.args) " . to_string ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-11-29 21:10:21 -05:00
argv : svec ! [ " arg1 " , " arg2 " ] ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2020-11-29 21:10:21 -05:00
allow_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2019-05-03 17:15:16 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn repl ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " ] ) ;
2019-05-03 17:15:16 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2022-04-20 08:16:37 -04:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
2022-12-07 14:21:18 -05:00
eval : None ,
is_default_command : true ,
2022-04-20 08:16:37 -04:00
} ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-08-10 07:19:45 -04:00
unsafely_ignore_certificate_errors : None ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2023-08-03 07:19:19 -04:00
deny_env : None ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2023-08-03 07:19:19 -04:00
deny_run : None ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2023-08-03 07:19:19 -04:00
deny_read : None ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2023-08-03 07:19:19 -04:00
deny_sys : None ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2023-08-03 07:19:19 -04:00
deny_write : None ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2023-08-03 07:19:19 -04:00
deny_ffi : None ,
2019-05-23 12:28:29 -04:00
allow_hrtime : true ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-05-03 17:15:16 -04:00
}
) ;
}
2023-11-10 12:41:24 -05:00
#[ test ]
fn repl_strace_ops ( ) {
// Lightly test this undocumented flag
let r = flags_from_vec ( svec! [ " deno " , " repl " , " --strace-ops " ] ) ;
assert_eq! ( r . unwrap ( ) . strace_ops , Some ( vec! [ ] ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " repl " , " --strace-ops=http,websocket " ] ) ;
assert_eq! (
r . unwrap ( ) . strace_ops ,
Some ( vec! [ " http " . to_string ( ) , " websocket " . to_string ( ) ] )
) ;
}
2020-04-30 11:23:40 -04:00
#[ test ]
2020-09-18 13:09:11 -04:00
fn repl_with_flags ( ) {
#[ rustfmt::skip ]
2023-11-01 11:21:13 -04:00
let r = flags_from_vec ( svec! [ " deno " , " repl " , " -A " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --location " , " https:foo " , " --v8-flags=--help " , " --seed " , " 1 " , " --inspect=127.0.0.1:9229 " , " --unsafely-ignore-certificate-errors " , " --env=.example.env " ] ) ;
2020-04-30 11:23:40 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2022-04-20 08:16:37 -04:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
2022-12-07 14:21:18 -05:00
eval : None ,
is_default_command : false ,
2022-04-20 08:16:37 -04:00
} ) ,
2020-09-18 13:09:11 -04:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2020-09-18 13:09:11 -04:00
reload : true ,
2020-10-19 15:19:20 -04:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-09-18 13:09:11 -04:00
lock_write : true ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2020-09-18 13:09:11 -04:00
cached_only : true ,
2021-01-07 13:06:08 -05:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
2020-09-18 13:09:11 -04:00
seed : Some ( 1 ) ,
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2022-12-07 14:21:18 -05:00
allow_all : true ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 18:12:00 -04:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 17:28:10 -04:00
allow_ffi : Some ( vec! [ ] ) ,
2020-04-30 11:23:40 -04:00
allow_hrtime : true ,
2023-11-01 11:21:13 -04:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
2021-12-10 09:47:55 -05:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2020-04-30 11:23:40 -04:00
.. Flags ::default ( )
}
) ;
}
2021-08-06 17:30:28 -04:00
#[ test ]
fn repl_with_eval_flag ( ) {
#[ rustfmt::skip ]
2022-12-07 14:21:18 -05:00
let r = flags_from_vec ( svec! [ " deno " , " repl " , " --allow-write " , " --eval " , " console.log('hello'); " ] ) ;
2021-08-06 17:30:28 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
2022-04-20 08:16:37 -04:00
eval_files : None ,
2021-08-06 17:30:28 -04:00
eval : Some ( " console.log('hello'); " . to_string ( ) ) ,
2022-12-07 14:21:18 -05:00
is_default_command : false ,
2021-09-03 19:33:35 -04:00
} ) ,
2021-08-06 17:30:28 -04:00
allow_write : Some ( vec! [ ] ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2021-08-06 17:30:28 -04:00
.. Flags ::default ( )
}
) ;
}
2022-04-20 08:16:37 -04:00
#[ test ]
fn repl_with_eval_file_flag ( ) {
#[ rustfmt::skip ]
let r = flags_from_vec ( svec! [ " deno " , " repl " , " --eval-file=./a.js,./b.ts,https://examples.deno.land/hello-world.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : Some ( vec! [
" ./a.js " . to_string ( ) ,
" ./b.ts " . to_string ( ) ,
" https://examples.deno.land/hello-world.ts " . to_string ( )
] ) ,
eval : None ,
2022-12-07 14:21:18 -05:00
is_default_command : false ,
2022-04-20 08:16:37 -04:00
} ) ,
type_check_mode : TypeCheckMode ::None ,
.. Flags ::default ( )
}
) ;
}
2019-05-08 19:20:30 -04:00
#[ test ]
2020-06-13 13:09:39 -04:00
fn allow_read_allowlist ( ) {
2022-04-01 11:15:37 -04:00
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
let temp_dir = temp_dir_guard . path ( ) . to_path_buf ( ) ;
2019-05-09 12:20:34 -04:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-05-08 19:20:30 -04:00
" deno " ,
" run " ,
2020-02-11 04:29:36 -05:00
format! ( " --allow-read=., {} " , temp_dir . to_str ( ) . unwrap ( ) ) ,
2019-05-08 19:20:30 -04:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ PathBuf ::from ( " . " ) , temp_dir ] ) ,
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-05-08 19:20:30 -04:00
}
) ;
}
2019-06-09 09:08:20 -04:00
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_read_denylist ( ) {
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
let temp_dir = temp_dir_guard . path ( ) . to_path_buf ( ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
format! ( " --deny-read=., {} " , temp_dir . to_str ( ) . unwrap ( ) ) ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
deny_read : Some ( vec! [ PathBuf ::from ( " . " ) , temp_dir ] ) ,
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
.. Flags ::default ( )
}
) ;
}
2019-05-08 19:20:30 -04:00
#[ test ]
2020-06-13 13:09:39 -04:00
fn allow_write_allowlist ( ) {
2022-04-01 11:15:37 -04:00
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
let temp_dir = temp_dir_guard . path ( ) . to_path_buf ( ) ;
2019-05-09 12:20:34 -04:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-05-08 19:20:30 -04:00
" deno " ,
" run " ,
2020-02-11 04:29:36 -05:00
format! ( " --allow-write=., {} " , temp_dir . to_str ( ) . unwrap ( ) ) ,
2019-05-08 19:20:30 -04:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ PathBuf ::from ( " . " ) , temp_dir ] ) ,
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-05-08 19:20:30 -04:00
}
) ;
}
2019-06-09 09:08:20 -04:00
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_write_denylist ( ) {
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
let temp_dir = temp_dir_guard . path ( ) . to_path_buf ( ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
format! ( " --deny-write=., {} " , temp_dir . to_str ( ) . unwrap ( ) ) ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
deny_write : Some ( vec! [ PathBuf ::from ( " . " ) , temp_dir ] ) ,
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
.. Flags ::default ( )
}
) ;
}
2019-05-08 19:20:30 -04:00
#[ test ]
2020-06-13 13:09:39 -04:00
fn allow_net_allowlist ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-05-08 19:20:30 -04:00
" deno " ,
" run " ,
" --allow-net=127.0.0.1 " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( svec! [ " 127.0.0.1 " ] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-05-08 19:20:30 -04:00
}
) ;
}
2019-06-01 08:54:32 -04:00
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_net_denylist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-net=127.0.0.1 " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_net : Some ( svec! [ " 127.0.0.1 " ] ) ,
.. Flags ::default ( )
}
) ;
}
2021-04-13 07:25:21 -04:00
#[ test ]
fn allow_env_allowlist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=HOME " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( svec! [ " HOME " ] ) ,
.. Flags ::default ( )
}
) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_env_denylist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=HOME " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_env : Some ( svec! [ " HOME " ] ) ,
.. Flags ::default ( )
}
) ;
}
2021-04-13 07:25:21 -04:00
#[ test ]
fn allow_env_allowlist_multiple ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-env=HOME,PATH " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-04-13 07:25:21 -04:00
allow_env : Some ( svec! [ " HOME " , " PATH " ] ) ,
.. Flags ::default ( )
}
) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_env_denylist_multiple ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=HOME,PATH " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_env : Some ( svec! [ " HOME " , " PATH " ] ) ,
.. Flags ::default ( )
}
) ;
}
2021-04-13 07:25:21 -04:00
#[ test ]
fn allow_env_allowlist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=HOME " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=H=ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=H \0 ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_env_denylist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=HOME " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=H=ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=H \0 ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-09-28 08:46:50 -04:00
#[ test ]
fn allow_sys ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_sys ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_sys : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
2022-09-28 08:46:50 -04:00
#[ test ]
fn allow_sys_allowlist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=hostname " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( svec! [ " hostname " ] ) ,
.. Flags ::default ( )
}
) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_sys_denylist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys=hostname " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_sys : Some ( svec! [ " hostname " ] ) ,
.. Flags ::default ( )
}
) ;
}
2022-09-28 08:46:50 -04:00
#[ test ]
fn allow_sys_allowlist_multiple ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-09-28 08:46:50 -04:00
allow_sys : Some ( svec! [ " hostname " , " osRelease " ] ) ,
.. Flags ::default ( )
}
) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_sys_denylist_multiple ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_sys : Some ( svec! [ " hostname " , " osRelease " ] ) ,
.. Flags ::default ( )
}
) ;
}
2022-09-28 08:46:50 -04:00
#[ test ]
fn allow_sys_allowlist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=hostname " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=foo " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-sys=hostname,foo " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) ) ;
}
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_sys_denylist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys=hostname " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys=foo " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-sys=hostname,foo " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-09-06 12:30:42 -04:00
#[ test ]
fn reload_validator ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/ " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) , " should accept valid urls " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/a,http://deno.land/b " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) , " should accept accept multiple valid urls " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=./relativeurl/ " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject relative urls that start with ./ " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=relativeurl/ " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject relative urls " ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --reload=/absolute " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject absolute urls " ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --reload=/ " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject absolute root url " ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --reload= " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject when nothing is provided " ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --reload=, " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject when a single comma is provided " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=,http://deno.land/a " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject a leading comma " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/a, " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject a trailing comma " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/a,,http://deno.land/b " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject adjacent commas " ) ;
}
2019-06-08 14:42:28 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn bundle ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " source.ts " ] ) ;
2019-06-08 14:42:28 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-02-04 14:24:33 -05:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-11-26 11:06:32 -05:00
}
) ;
}
2020-05-07 11:02:03 -04:00
#[ test ]
fn bundle_with_config ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-05-07 11:02:03 -04:00
" deno " ,
" bundle " ,
2020-09-18 13:09:11 -04:00
" --no-remote " ,
2020-05-07 11:02:03 -04:00
" --config " ,
" tsconfig.json " ,
" source.ts " ,
" bundle.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-05-07 11:02:03 -04:00
source_file : " source.ts " . to_string ( ) ,
2024-01-15 19:15:39 -05:00
out_file : Some ( " bundle.js " . to_string ( ) ) ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2020-09-18 13:09:11 -04:00
no_remote : true ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2020-05-07 11:02:03 -04:00
.. Flags ::default ( )
}
) ;
}
2019-11-26 11:06:32 -05:00
#[ test ]
fn bundle_with_output ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " source.ts " , " bundle.js " ] ) ;
2019-11-26 11:06:32 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-02-04 14:24:33 -05:00
source_file : " source.ts " . to_string ( ) ,
2024-01-15 19:15:39 -05:00
out_file : Some ( " bundle.js " . to_string ( ) ) ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-12-29 13:34:35 -05:00
allow_write : Some ( vec! [ ] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2020-07-07 07:05:28 -04:00
}
) ;
}
#[ test ]
fn bundle_with_lock ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-07-07 07:05:28 -04:00
" deno " ,
" bundle " ,
" --lock-write " ,
" --lock=lock.json " ,
" source.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-07-07 07:05:28 -04:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-07-07 07:05:28 -04:00
lock_write : true ,
2020-10-19 15:19:20 -04:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-07-07 07:05:28 -04:00
.. Flags ::default ( )
2019-06-08 14:42:28 -04:00
}
) ;
}
2019-06-09 09:08:20 -04:00
2020-08-12 11:32:03 -04:00
#[ test ]
fn bundle_with_reload ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " --reload " , " source.ts " ] ) ;
2020-08-12 11:32:03 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
reload : true ,
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-08-12 11:32:03 -04:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-08-12 11:32:03 -04:00
.. Flags ::default ( )
}
) ;
}
2020-10-19 23:10:42 -04:00
#[ test ]
fn bundle_nocheck ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " --no-check " , " script.ts " ] )
. unwrap ( ) ;
2020-10-19 23:10:42 -04:00
assert_eq! (
r ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-10-19 23:10:42 -04:00
source_file : " script.ts " . to_string ( ) ,
out_file : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2020-10-19 23:10:42 -04:00
.. Flags ::default ( )
}
) ;
}
2020-11-22 15:45:44 -05:00
#[ test ]
fn bundle_watch ( ) {
2021-04-27 06:44:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " --watch " , " source.ts " ] ) ;
2020-11-22 15:45:44 -05:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-11-22 15:45:44 -05:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-11-22 15:45:44 -05:00
.. Flags ::default ( )
}
)
}
2022-01-31 11:39:39 -05:00
#[ test ]
fn bundle_watch_with_no_clear_screen ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" bundle " ,
" --watch " ,
" --no-clear-screen " ,
" source.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2023-06-15 13:09:37 -04:00
watch : Some ( WatchFlags {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
no_clear_screen : true ,
} ) ,
2022-01-31 11:39:39 -05:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-01-31 11:39:39 -05:00
.. Flags ::default ( )
}
)
}
2019-06-09 09:08:20 -04:00
#[ test ]
2020-10-20 08:30:59 -04:00
fn run_import_map ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-06-09 09:08:20 -04:00
" deno " ,
" run " ,
2020-10-20 08:30:59 -04:00
" --import-map=import_map.json " ,
2019-06-09 09:08:20 -04:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-10-20 08:30:59 -04:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-09 09:08:20 -04:00
}
) ;
2019-11-26 11:06:32 -05:00
}
2019-06-09 09:08:20 -04:00
2020-09-21 09:07:19 -04:00
#[ test ]
2020-10-20 08:30:59 -04:00
fn info_import_map ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-09-21 09:07:19 -04:00
" deno " ,
" info " ,
2020-10-20 08:30:59 -04:00
" --import-map=import_map.json " ,
2020-09-21 09:07:19 -04:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-09-21 09:07:19 -04:00
file : Some ( " script.ts " . to_string ( ) ) ,
json : false ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-10-20 08:30:59 -04:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-09-21 09:07:19 -04:00
.. Flags ::default ( )
}
) ;
}
2019-11-26 11:06:32 -05:00
#[ test ]
2020-10-20 08:30:59 -04:00
fn cache_import_map ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-07-27 10:37:03 -04:00
" deno " ,
2020-04-07 11:24:47 -04:00
" cache " ,
2020-10-20 08:30:59 -04:00
" --import-map=import_map.json " ,
2019-07-27 10:37:03 -04:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-02-04 14:24:33 -05:00
files : svec ! [ " script.ts " ] ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-10-20 08:30:59 -04:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-10-11 19:05:46 -04:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
2020-10-20 08:30:59 -04:00
fn doc_import_map ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-10-11 19:05:46 -04:00
" deno " ,
" doc " ,
2020-10-20 08:30:59 -04:00
" --import-map=import_map.json " ,
2020-10-11 19:05:46 -04:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2023-10-30 18:58:57 -04:00
source_files : DocSourceFileFlag ::Paths ( vec! [ " script.ts " . to_owned ( ) ] ) ,
2020-10-11 19:05:46 -04:00
private : false ,
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-31 18:19:42 -04:00
lint : false ,
2020-10-11 19:05:46 -04:00
filter : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-10-20 08:30:59 -04:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-07-27 10:37:03 -04:00
}
) ;
2019-06-09 09:08:20 -04:00
}
2019-06-11 10:34:39 -04:00
2023-11-01 11:21:13 -04:00
#[ test ]
fn run_env_file_default ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --env " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-11-01 11:21:13 -04:00
env_file : Some ( " .env " . to_owned ( ) ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_env_file_defined ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --env=.another_env " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-11-01 11:21:13 -04:00
env_file : Some ( " .another_env " . to_owned ( ) ) ,
.. Flags ::default ( )
}
) ;
}
2020-01-31 16:07:37 -05:00
#[ test ]
2020-04-07 11:24:47 -04:00
fn cache_multiple ( ) {
2020-01-31 16:07:37 -05:00
let r =
2021-01-07 13:06:08 -05:00
flags_from_vec ( svec! [ " deno " , " cache " , " script.ts " , " script_two.ts " ] ) ;
2020-01-31 16:07:37 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-02-04 14:24:33 -05:00
files : svec ! [ " script.ts " , " script_two.ts " ] ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2020-01-31 16:07:37 -05:00
}
) ;
}
2019-06-11 10:34:39 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn run_seed ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --seed " , " 250 " , " script.ts " ] ) ;
2019-06-11 10:34:39 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-11-27 14:47:35 -05:00
seed : Some ( 250_ u64 ) ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --random-seed=250 " ] ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-11 10:34:39 -04:00
}
) ;
}
#[ test ]
2019-11-26 11:06:32 -05:00
fn run_seed_with_v8_flags ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-06-11 10:34:39 -04:00
" deno " ,
2019-11-26 11:06:32 -05:00
" run " ,
2019-06-11 10:34:39 -04:00
" --seed " ,
" 250 " ,
" --v8-flags=--expose-gc " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-11-27 14:47:35 -05:00
seed : Some ( 250_ u64 ) ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --expose-gc " , " --random-seed=250 " ] ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-11 10:34:39 -04:00
}
) ;
2019-06-15 10:08:11 -04:00
}
#[ test ]
2019-11-26 11:06:32 -05:00
fn install ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-06-15 10:08:11 -04:00
" deno " ,
" install " ,
2023-12-01 21:20:06 -05:00
" https://deno.land/std/http/file_server.ts "
2019-06-15 10:08:11 -04:00
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Install ( InstallFlags {
2020-05-01 15:33:11 -04:00
name : None ,
2023-12-01 21:20:06 -05:00
module_url : " https://deno.land/std/http/file_server.ts " . to_string ( ) ,
2020-01-30 18:42:39 -05:00
args : vec ! [ ] ,
2020-05-01 15:33:11 -04:00
root : None ,
2020-02-08 03:49:55 -05:00
force : false ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-15 10:08:11 -04:00
}
) ;
2019-11-26 11:06:32 -05:00
}
2019-06-15 10:08:11 -04:00
2019-11-26 11:06:32 -05:00
#[ test ]
2020-10-19 15:19:20 -04:00
fn install_with_flags ( ) {
#[ rustfmt::skip ]
2023-11-01 11:21:13 -04:00
let r = flags_from_vec ( svec! [ " deno " , " install " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --unsafely-ignore-certificate-errors " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --allow-read " , " --allow-net " , " --v8-flags=--help " , " --seed " , " 1 " , " --inspect=127.0.0.1:9229 " , " --name " , " file_server " , " --root " , " /foo " , " --force " , " --env=.example.env " , " https://deno.land/std/http/file_server.ts " , " foo " , " bar " ] ) ;
2019-06-20 14:25:13 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Install ( InstallFlags {
2020-05-01 15:33:11 -04:00
name : Some ( " file_server " . to_string ( ) ) ,
2020-01-30 18:42:39 -05:00
module_url : " https://deno.land/std/http/file_server.ts " . to_string ( ) ,
2020-10-19 15:19:20 -04:00
args : svec ! [ " foo " , " bar " ] ,
2023-11-13 09:44:01 -05:00
root : Some ( " /foo " . to_string ( ) ) ,
2020-02-08 03:49:55 -05:00
force : true ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-10-19 15:19:20 -04:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2020-10-19 15:19:20 -04:00
reload : true ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
lock_write : true ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2020-10-19 15:19:20 -04:00
cached_only : true ,
2020-12-06 12:19:21 -05:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
2020-10-19 15:19:20 -04:00
seed : Some ( 1 ) ,
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2021-08-10 07:19:45 -04:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2023-11-01 11:21:13 -04:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-20 14:25:13 -04:00
}
) ;
2019-06-11 10:34:39 -04:00
}
2019-06-22 12:02:51 -04:00
2023-01-05 21:09:39 -05:00
#[ test ]
fn uninstall ( ) {
let r = flags_from_vec ( svec! [ " deno " , " uninstall " , " file_server " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Uninstall ( UninstallFlags {
name : " file_server " . to_string ( ) ,
root : None ,
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn uninstall_with_help_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " uninstall " , " --help " ] ) ;
2023-03-26 00:06:18 -04:00
assert_eq! ( r . err ( ) . unwrap ( ) . kind ( ) , clap ::error ::ErrorKind ::DisplayHelp ) ;
2023-01-05 21:09:39 -05:00
}
2019-06-22 12:02:51 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn log_level ( ) {
2021-01-07 13:06:08 -05:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --log-level=debug " , " script.ts " ] ) ;
2019-06-22 12:02:51 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-06-22 12:02:51 -04:00
log_level : Some ( Level ::Debug ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-22 12:02:51 -04:00
}
) ;
}
2019-06-26 06:02:13 -04:00
2020-03-10 08:26:17 -04:00
#[ test ]
fn quiet ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " -q " , " script.ts " ] ) ;
2020-03-10 08:26:17 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-03-10 08:26:17 -04:00
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
}
2019-06-26 06:02:13 -04:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn completions ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " completions " , " zsh " ] ) . unwrap ( ) ;
2020-02-04 14:24:33 -05:00
match r . subcommand {
2021-09-03 19:33:35 -04:00
DenoSubcommand ::Completions ( CompletionsFlags { buf } ) = > {
assert! ( ! buf . is_empty ( ) )
}
2020-02-04 14:24:33 -05:00
_ = > unreachable! ( ) ,
}
2019-06-26 06:02:13 -04:00
}
2019-06-29 18:32:54 -04:00
#[ test ]
2020-08-28 19:20:57 -04:00
fn run_with_args ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-08-28 19:20:57 -04:00
" deno " ,
" run " ,
" script.ts " ,
" --allow-read " ,
" --allow-net "
] ) ;
2019-06-29 18:32:54 -04:00
assert_eq! (
2020-08-28 19:20:57 -04:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 19:20:57 -04:00
argv : svec ! [ " --allow-read " , " --allow-net " ] ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-29 18:32:54 -04:00
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-06-29 18:32:54 -04:00
" deno " ,
" run " ,
2021-01-07 13:06:08 -05:00
" --location " ,
" https:foo " ,
2019-11-26 11:06:32 -05:00
" --allow-read " ,
2019-06-29 18:32:54 -04:00
" script.ts " ,
" --allow-net " ,
" -r " ,
" --help " ,
" --foo " ,
" bar "
] ) ;
assert_eq! (
2020-08-28 19:20:57 -04:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-01-07 13:06:08 -05:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2020-12-29 13:34:35 -05:00
allow_read : Some ( vec! [ ] ) ,
2020-08-28 19:20:57 -04:00
argv : svec ! [ " --allow-net " , " -r " , " --help " , " --foo " , " bar " ] ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-06-29 18:32:54 -04:00
}
) ;
2020-08-28 19:20:57 -04:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " script.ts " , " foo " , " bar " ] ) ;
2020-08-28 19:20:57 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 19:20:57 -04:00
argv : svec ! [ " foo " , " bar " ] ,
.. Flags ::default ( )
}
) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " script.ts " , " - " ] ) ;
2020-08-28 19:20:57 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 19:20:57 -04:00
argv : svec ! [ " - " ] ,
.. Flags ::default ( )
}
) ;
let r =
2021-01-07 13:06:08 -05:00
flags_from_vec ( svec! [ " deno " , " run " , " script.ts " , " - " , " foo " , " bar " ] ) ;
2020-08-28 19:20:57 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 19:20:57 -04:00
argv : svec ! [ " - " , " foo " , " bar " ] ,
.. Flags ::default ( )
}
) ;
}
2019-07-20 09:19:06 -04:00
2020-07-08 05:26:39 -04:00
#[ test ]
fn no_check ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-check " , " script.ts " ] ) ;
2020-07-08 05:26:39 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2021-11-29 17:23:30 -05:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn no_check_remote ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --no-check=remote " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-07-08 05:26:39 -04:00
.. Flags ::default ( )
}
) ;
}
2021-08-09 10:53:21 -04:00
#[ test ]
2021-12-10 09:47:55 -05:00
fn repl_with_unsafely_ignore_certificate_errors ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" repl " ,
" --eval " ,
" console.log('hello'); " ,
" --unsafely-ignore-certificate-errors "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Repl ( ReplFlags {
2022-04-20 08:16:37 -04:00
eval_files : None ,
2021-12-10 09:47:55 -05:00
eval : Some ( " console.log('hello'); " . to_string ( ) ) ,
2022-12-07 14:21:18 -05:00
is_default_command : false ,
2021-12-10 09:47:55 -05:00
} ) ,
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2021-12-10 09:47:55 -05:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_with_unsafely_ignore_certificate_errors ( ) {
2021-08-09 10:53:21 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
2021-08-10 07:19:45 -04:00
" --unsafely-ignore-certificate-errors " ,
2021-08-09 10:53:21 -04:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-08-10 07:19:45 -04:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2021-08-09 10:53:21 -04:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
2021-12-10 09:47:55 -05:00
fn run_with_unsafely_treat_insecure_origin_as_secure_with_ipv6_address ( ) {
2021-08-09 10:53:21 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
2021-08-10 07:19:45 -04:00
" --unsafely-ignore-certificate-errors=deno.land,localhost,::,127.0.0.1,[::1],1.2.3.4 " ,
2021-08-09 10:53:21 -04:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-08-10 07:19:45 -04:00
unsafely_ignore_certificate_errors : Some ( svec! [
2021-08-09 10:53:21 -04:00
" deno.land " ,
" localhost " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4 "
] ) ,
.. Flags ::default ( )
}
) ;
}
2021-12-10 09:47:55 -05:00
#[ test ]
fn repl_with_unsafely_treat_insecure_origin_as_secure_with_ipv6_address ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" repl " ,
" --unsafely-ignore-certificate-errors=deno.land,localhost,::,127.0.0.1,[::1],1.2.3.4 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2022-04-20 08:16:37 -04:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
2022-12-07 14:21:18 -05:00
eval : None ,
is_default_command : false ,
2022-04-20 08:16:37 -04:00
} ) ,
2021-12-10 09:47:55 -05:00
unsafely_ignore_certificate_errors : Some ( svec! [
" deno.land " ,
" localhost " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4 "
] ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2021-12-10 09:47:55 -05:00
.. Flags ::default ( )
}
) ;
}
2019-07-20 09:19:06 -04:00
#[ test ]
2019-12-03 17:48:53 -05:00
fn no_remote ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-remote " , " script.ts " ] ) ;
2019-12-03 17:48:53 -05:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-12-03 17:48:53 -05:00
no_remote : true ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-12-03 17:48:53 -05:00
}
) ;
}
2022-09-07 09:33:51 -04:00
#[ test ]
fn no_npm ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-npm " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-09-07 09:33:51 -04:00
no_npm : true ,
.. Flags ::default ( )
}
) ;
}
2022-09-22 11:17:02 -04:00
#[ test ]
fn local_npm ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --node-modules-dir " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-02-20 13:14:06 -05:00
node_modules_dir : Some ( true ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --node-modules-dir=false " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-02-20 13:14:06 -05:00
node_modules_dir : Some ( false ) ,
2022-09-22 11:17:02 -04:00
.. Flags ::default ( )
}
) ;
}
2023-08-01 20:49:09 -04:00
#[ test ]
2023-08-06 21:56:56 -04:00
fn vendor_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --vendor " , " script.ts " ] ) ;
2023-08-01 20:49:09 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-06 21:56:56 -04:00
vendor : Some ( true ) ,
2023-08-01 20:49:09 -04:00
.. Flags ::default ( )
}
) ;
2023-08-06 21:56:56 -04:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --vendor=false " , " script.ts " ] ) ;
2023-08-01 20:49:09 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-06 21:56:56 -04:00
vendor : Some ( false ) ,
2023-08-01 20:49:09 -04:00
.. Flags ::default ( )
}
) ;
}
2019-12-03 17:48:53 -05:00
#[ test ]
fn cached_only ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --cached-only " , " script.ts " ] ) ;
2019-07-20 09:19:06 -04:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-12-03 17:48:53 -05:00
cached_only : true ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-07-20 09:19:06 -04:00
}
) ;
}
2019-07-31 11:02:20 -04:00
2019-10-12 17:13:52 -04:00
#[ test ]
2020-06-13 13:09:39 -04:00
fn allow_net_allowlist_with_ports ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-10-12 17:13:52 -04:00
" deno " ,
2020-05-04 07:03:30 -04:00
" run " ,
2019-10-12 17:13:52 -04:00
" --allow-net=deno.land,:8000,:4545 " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( svec! [
2019-10-12 17:13:52 -04:00
" deno.land " ,
" 0.0.0.0:8000 " ,
" 127.0.0.1:8000 " ,
" localhost:8000 " ,
" 0.0.0.0:4545 " ,
" 127.0.0.1:4545 " ,
" localhost:4545 "
2020-12-29 13:34:35 -05:00
] ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-10-12 17:13:52 -04:00
}
) ;
}
2019-11-03 10:39:27 -05:00
2023-08-03 07:19:19 -04:00
#[ test ]
fn deny_net_denylist_with_ports ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-net=deno.land,:8000,:4545 " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_net : Some ( svec! [
" deno.land " ,
" 0.0.0.0:8000 " ,
" 127.0.0.1:8000 " ,
" localhost:8000 " ,
" 0.0.0.0:4545 " ,
" 127.0.0.1:4545 " ,
" localhost:4545 "
] ) ,
.. Flags ::default ( )
}
) ;
}
2020-06-26 08:09:02 -04:00
#[ test ]
fn allow_net_allowlist_with_ipv6_address ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-06-26 08:09:02 -04:00
" deno " ,
" run " ,
" --allow-net=deno.land,deno.land:80,::,127.0.0.1,[::1],1.2.3.4:5678,:5678,[::1]:8080 " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( svec! [
2023-08-03 07:19:19 -04:00
" deno.land " ,
" deno.land:80 " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4:5678 " ,
" 0.0.0.0:5678 " ,
" 127.0.0.1:5678 " ,
" localhost:5678 " ,
" [::1]:8080 "
] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn deny_net_denylist_with_ipv6_address ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-net=deno.land,deno.land:80,::,127.0.0.1,[::1],1.2.3.4:5678,:5678,[::1]:8080 " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-03 07:19:19 -04:00
deny_net : Some ( svec! [
2020-06-26 08:09:02 -04:00
" deno.land " ,
" deno.land:80 " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4:5678 " ,
" 0.0.0.0:5678 " ,
" 127.0.0.1:5678 " ,
" localhost:5678 " ,
" [::1]:8080 "
2020-12-29 13:34:35 -05:00
] ) ,
2020-06-26 08:09:02 -04:00
.. Flags ::default ( )
}
) ;
}
2019-11-03 10:39:27 -05:00
#[ test ]
2019-11-26 11:06:32 -05:00
fn lock_write ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2019-11-03 10:39:27 -05:00
" deno " ,
2020-05-04 07:03:30 -04:00
" run " ,
2019-11-03 10:39:27 -05:00
" --lock-write " ,
" --lock=lock.json " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-11-03 10:39:27 -05:00
lock_write : true ,
2020-10-19 15:19:20 -04:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-02-26 05:52:15 -05:00
.. Flags ::default ( )
2019-11-03 10:39:27 -05:00
}
) ;
2022-11-02 11:32:30 -04:00
2022-11-03 11:42:56 -04:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-lock " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-03 11:42:56 -04:00
no_lock : true ,
.. Flags ::default ( )
}
) ;
2022-11-02 11:32:30 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock " ,
" --lock-write " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-02 11:32:30 -04:00
lock_write : true ,
lock : Some ( PathBuf ::from ( " ./deno.lock " ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock-write " ,
" --lock " ,
" lock.json " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-02 11:32:30 -04:00
lock_write : true ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --lock-write " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-02 11:32:30 -04:00
lock_write : true ,
.. Flags ::default ( )
}
) ;
2022-11-03 11:42:56 -04:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --lock " , " --no-lock " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock-write " ,
" --no-lock " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , ) ;
2019-11-03 10:39:27 -05:00
}
2019-11-13 11:21:17 -05:00
2023-01-09 07:29:43 -05:00
#[ test ]
fn test_no_colon_in_value_name ( ) {
let app =
runtime_args ( Command ::new ( " test_inspect_completion_value " ) , true , true ) ;
let inspect_args = app
. get_arguments ( )
. filter ( | arg | arg . get_id ( ) = = " inspect " )
. collect ::< Vec < _ > > ( ) ;
// The value_name cannot have a : otherwise it breaks shell completions for zsh.
let value_name = " HOST_AND_PORT " ;
let arg = inspect_args
. iter ( )
. any ( | v | v . get_value_names ( ) . unwrap ( ) = = [ value_name ] ) ;
assert_eq! ( arg , true ) ;
}
2019-11-26 11:06:32 -05:00
#[ test ]
2020-11-22 08:06:51 -05:00
fn test_with_flags ( ) {
#[ rustfmt::skip ]
2023-03-13 17:04:00 -04:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --unstable " , " --no-npm " , " --no-remote " , " --trace-ops " , " --no-run " , " --filter " , " - foo " , " --coverage=cov " , " --location " , " https:foo " , " --allow-net " , " --allow-none " , " dir1/ " , " dir2/ " , " -- " , " arg1 " , " arg2 " ] ) ;
2019-11-13 11:21:17 -05:00
assert_eq! (
2019-11-26 11:06:32 -05:00
r . unwrap ( ) ,
2020-02-26 05:52:15 -05:00
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2020-11-22 08:06:51 -05:00
no_run : true ,
2021-05-10 19:54:39 -04:00
doc : false ,
2021-07-12 06:55:42 -04:00
fail_fast : None ,
2020-11-22 08:06:51 -05:00
filter : Some ( " - foo " . to_string ( ) ) ,
2020-02-11 06:01:56 -05:00
allow_none : true ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " dir1/ " . to_string ( ) , " dir2/ " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2021-07-05 21:20:33 -04:00
shuffle : None ,
2023-01-07 15:22:09 -05:00
concurrent_jobs : None ,
2022-02-25 10:14:46 -05:00
trace_ops : true ,
2023-06-15 13:09:37 -04:00
coverage_dir : Some ( " cov " . to_string ( ) ) ,
watch : Default ::default ( ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-09-13 09:01:30 -04:00
unstable : true ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2023-03-13 17:04:00 -04:00
no_npm : true ,
no_remote : true ,
2021-01-07 13:06:08 -05:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-12-29 13:34:35 -05:00
allow_net : Some ( vec! [ ] ) ,
2020-10-25 20:25:43 -04:00
argv : svec ! [ " arg1 " , " arg2 " ] ,
.. Flags ::default ( )
}
) ;
}
2020-04-02 09:26:40 -04:00
#[ test ]
fn run_with_cafile ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-04-02 09:26:40 -04:00
" deno " ,
" run " ,
" --cert " ,
" example.crt " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 11:59:51 -05:00
2021-07-23 10:31:16 -04:00
#[ test ]
fn run_with_enable_testing_features ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --enable-testing-features-do-not-use " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-07-23 10:31:16 -04:00
enable_testing_features : true ,
.. Flags ::default ( )
}
) ;
}
2021-08-23 06:35:38 -04:00
#[ test ]
fn test_with_concurrent_jobs ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --jobs=4 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-08-23 06:35:38 -04:00
no_run : false ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2021-08-23 06:35:38 -04:00
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : Some ( NonZeroUsize ::new ( 4 ) . unwrap ( ) ) ,
2022-02-25 10:14:46 -05:00
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2021-08-23 06:35:38 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --jobs=0 " ] ) ;
assert! ( r . is_err ( ) ) ;
}
2021-07-12 06:55:42 -04:00
#[ test ]
fn test_with_fail_fast ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --fail-fast=3 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-12 06:55:42 -04:00
no_run : false ,
doc : false ,
2021-08-23 06:37:02 -04:00
fail_fast : Some ( NonZeroUsize ::new ( 3 ) . unwrap ( ) ) ,
2021-07-12 06:55:42 -04:00
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 10:14:46 -05:00
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2021-07-12 06:55:42 -04:00
.. Flags ::default ( )
}
) ;
2021-08-23 06:37:02 -04:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --fail-fast=0 " ] ) ;
assert! ( r . is_err ( ) ) ;
2021-07-12 06:55:42 -04:00
}
2021-07-23 10:31:16 -04:00
#[ test ]
fn test_with_enable_testing_features ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" test " ,
" --enable-testing-features-do-not-use "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-23 10:31:16 -04:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 10:14:46 -05:00
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2021-07-23 10:31:16 -04:00
enable_testing_features : true ,
.. Flags ::default ( )
}
) ;
}
2021-07-27 14:18:16 -04:00
2023-08-02 12:38:10 -04:00
#[ test ]
2023-08-02 22:05:34 -04:00
fn test_reporter ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=pretty " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Pretty ,
.. Default ::default ( )
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=dot " ] ) ;
2023-08-02 12:38:10 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Dot ,
2023-08-02 22:05:34 -04:00
.. Default ::default ( )
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=junit " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Junit ,
.. Default ::default ( )
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
2023-08-25 19:19:23 -04:00
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=tap " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Tap ,
.. Default ::default ( )
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
2023-08-02 22:05:34 -04:00
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" test " ,
" --reporter=dot " ,
" --junit-path=report.xml "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Dot ,
junit_path : Some ( " report.xml " . to_string ( ) ) ,
.. Default ::default ( )
2023-08-02 12:38:10 -04:00
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
2023-08-02 22:05:34 -04:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --junit-path " ] ) ;
2023-08-02 12:38:10 -04:00
assert! ( r . is_err ( ) ) ;
}
2021-07-27 14:18:16 -04:00
#[ test ]
fn test_shuffle ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --shuffle=1 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-27 14:18:16 -04:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : Some ( 1 ) ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 10:14:46 -05:00
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2021-07-27 14:18:16 -04:00
.. Flags ::default ( )
}
) ;
}
2021-07-20 05:29:17 -04:00
#[ test ]
fn test_watch ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --watch " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-20 05:29:17 -04:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2023-01-07 15:22:09 -05:00
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn test_watch_explicit_cwd ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --watch " , " ./ " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " ./ " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 10:14:46 -05:00
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2021-07-20 05:29:17 -04:00
.. Flags ::default ( )
}
) ;
}
2022-01-31 11:39:39 -05:00
#[ test ]
fn test_watch_with_no_clear_screen ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " test " , " --watch " , " --no-clear-screen " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 10:14:46 -05:00
trace_ops : false ,
2023-06-15 13:09:37 -04:00
coverage_dir : None ,
watch : Some ( WatchFlags {
2023-10-30 20:25:58 -04:00
hmr : false ,
2023-06-15 13:09:37 -04:00
no_clear_screen : true ,
} ) ,
2023-08-02 12:38:10 -04:00
reporter : Default ::default ( ) ,
2023-08-02 22:05:34 -04:00
junit_path : None ,
2022-01-31 11:39:39 -05:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-02-26 08:49:50 -05:00
no_prompt : true ,
2022-01-31 11:39:39 -05:00
.. Flags ::default ( )
2023-12-08 03:35:42 -05:00
}
) ;
}
#[ test ]
fn test_coverage_default_dir ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --coverage " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
coverage_dir : Some ( " coverage " . to_string ( ) ) ,
.. TestFlags ::default ( )
} ) ,
type_check_mode : TypeCheckMode ::Local ,
no_prompt : true ,
.. Flags ::default ( )
2022-01-31 11:39:39 -05:00
}
) ;
}
2020-04-02 09:26:40 -04:00
#[ test ]
fn bundle_with_cafile ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-04-02 09:26:40 -04:00
" deno " ,
" bundle " ,
" --cert " ,
" example.crt " ,
" source.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-04-02 09:26:40 -04:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 11:59:51 -05:00
2020-07-05 23:58:23 -04:00
#[ test ]
fn upgrade_with_ca_file ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " upgrade " , " --cert " , " example.crt " ] ) ;
2020-07-05 23:58:23 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Upgrade ( UpgradeFlags {
2020-07-05 23:58:23 -04:00
force : false ,
dry_run : false ,
2020-11-29 14:00:35 -05:00
canary : false ,
2020-07-05 23:58:23 -04:00
version : None ,
2020-07-06 18:21:26 -04:00
output : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-07-05 23:58:23 -04:00
.. Flags ::default ( )
}
) ;
}
2020-04-02 09:26:40 -04:00
#[ test ]
2020-04-07 11:24:47 -04:00
fn cache_with_cafile ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-04-02 09:26:40 -04:00
" deno " ,
2020-04-07 11:24:47 -04:00
" cache " ,
2020-04-02 09:26:40 -04:00
" --cert " ,
" example.crt " ,
" script.ts " ,
" script_two.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-04-02 09:26:40 -04:00
files : svec ! [ " script.ts " , " script_two.ts " ] ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 11:59:51 -05:00
2020-04-02 09:26:40 -04:00
#[ test ]
fn info_with_cafile ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-04-02 09:26:40 -04:00
" deno " ,
" info " ,
" --cert " ,
" example.crt " ,
" https://example.com "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 10:50:12 -04:00
json : false ,
2020-04-02 09:26:40 -04:00
file : Some ( " https://example.com " . to_string ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 11:59:51 -05:00
2020-04-02 09:26:40 -04:00
#[ test ]
fn doc ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --json " , " path/to/module.ts " ] ) ;
2020-04-02 09:26:40 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 08:16:33 -04:00
private : false ,
2020-04-02 09:26:40 -04:00
json : true ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-31 18:19:42 -04:00
lint : false ,
2023-11-01 11:25:05 -04:00
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.ts " ] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --html " , " path/to/module.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --html " ,
" --name=My library " ,
" path/to/module.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
json : false ,
lint : false ,
html : Some ( DocHtmlFlag {
name : " My library " . to_string ( ) ,
output : PathBuf ::from ( " ./docs/ " ) ,
} ) ,
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.ts " ] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --html " ,
" --name=My library " ,
" --lint " ,
" --output=./foo " ,
" path/to/module.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
json : false ,
html : Some ( DocHtmlFlag {
name : " My library " . to_string ( ) ,
output : PathBuf ::from ( " ./foo " ) ,
} ) ,
lint : true ,
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.ts " ] ) ,
2020-04-02 09:26:40 -04:00
filter : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
2020-03-28 14:16:57 -04:00
2023-11-03 13:06:18 -04:00
let r =
flags_from_vec ( svec! [ " deno " , " doc " , " --html " , " --name=My library " , ] ) ;
assert! ( r . is_err ( ) ) ;
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-04-02 09:26:40 -04:00
" deno " ,
" doc " ,
2023-10-30 18:58:57 -04:00
" --filter " ,
" SomeClass.someField " ,
2020-04-02 09:26:40 -04:00
" path/to/module.ts " ,
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 08:16:33 -04:00
private : false ,
2020-04-02 09:26:40 -04:00
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-31 18:19:42 -04:00
lint : false ,
2023-10-30 18:58:57 -04:00
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.ts " . to_string ( )
] ) ,
2020-04-02 09:26:40 -04:00
filter : Some ( " SomeClass.someField " . to_string ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
2020-04-09 08:34:24 -04:00
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " doc " ] ) ;
2020-04-09 08:34:24 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 08:16:33 -04:00
private : false ,
2020-04-09 08:34:24 -04:00
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-31 18:19:42 -04:00
lint : false ,
2023-10-30 18:58:57 -04:00
source_files : Default ::default ( ) ,
2020-04-09 08:34:24 -04:00
filter : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-04-09 08:34:24 -04:00
.. Flags ::default ( )
}
) ;
2023-10-30 18:58:57 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --filter " ,
" Deno.Listener " ,
" --builtin "
] ) ;
2020-04-09 08:34:24 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 08:16:33 -04:00
private : false ,
2023-10-31 18:19:42 -04:00
lint : false ,
2020-04-09 08:34:24 -04:00
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-30 18:58:57 -04:00
source_files : DocSourceFileFlag ::Builtin ,
2020-04-09 08:34:24 -04:00
filter : Some ( " Deno.Listener " . to_string ( ) ) ,
2021-09-03 19:33:35 -04:00
} ) ,
2020-04-09 08:34:24 -04:00
.. Flags ::default ( )
}
) ;
2020-07-12 08:16:33 -04:00
2023-03-13 17:04:00 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --no-npm " ,
" --no-remote " ,
" --private " ,
" path/to/module.js "
] ) ;
2020-07-12 08:16:33 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 08:16:33 -04:00
private : true ,
2023-10-31 18:19:42 -04:00
lint : false ,
2020-07-12 08:16:33 -04:00
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.js " ] ) ,
2020-07-12 08:16:33 -04:00
filter : None ,
2021-09-03 19:33:35 -04:00
} ) ,
2023-03-13 17:04:00 -04:00
no_npm : true ,
no_remote : true ,
2020-07-12 08:16:33 -04:00
.. Flags ::default ( )
}
) ;
2023-10-30 18:58:57 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" path/to/module.js " ,
" path/to/module2.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
2023-10-31 18:19:42 -04:00
lint : false ,
2023-10-30 18:58:57 -04:00
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-30 18:58:57 -04:00
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.js " . to_string ( ) ,
" path/to/module2.js " . to_string ( )
] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" path/to/module.js " ,
" --builtin " ,
" path/to/module2.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-31 18:19:42 -04:00
lint : false ,
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.js " . to_string ( ) ,
" path/to/module2.js " . to_string ( )
] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
2023-11-03 13:06:18 -04:00
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --lint " , ] ) ;
assert! ( r . is_err ( ) ) ;
2023-10-31 18:19:42 -04:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --lint " ,
" path/to/module.js " ,
" path/to/module2.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
lint : true ,
json : false ,
2023-11-01 11:25:05 -04:00
html : None ,
2023-10-30 18:58:57 -04:00
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.js " . to_string ( ) ,
" path/to/module2.js " . to_string ( )
] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
2020-04-02 09:26:40 -04:00
}
2020-03-27 16:09:51 -04:00
2020-04-02 09:26:40 -04:00
#[ test ]
fn inspect_default_host ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --inspect " , " foo.js " ] ) ;
2020-04-02 09:26:40 -04:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" foo.js " . to_string ( ) ,
) ) ,
2020-04-03 13:40:11 -04:00
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2020-04-02 09:26:40 -04:00
.. Flags ::default ( )
}
) ;
}
2020-11-30 14:35:12 -05:00
2022-12-12 09:33:30 -05:00
#[ test ]
fn inspect_wait ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --inspect-wait " , " foo.js " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" foo.js " . to_string ( ) ,
) ) ,
2022-12-12 09:33:30 -05:00
inspect_wait : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --inspect-wait=127.0.0.1:3567 " ,
" foo.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" foo.js " . to_string ( ) ,
) ) ,
2022-12-12 09:33:30 -05:00
inspect_wait : Some ( " 127.0.0.1:3567 " . parse ( ) . unwrap ( ) ) ,
.. Flags ::default ( )
}
) ;
}
2020-11-30 14:35:12 -05:00
#[ test ]
fn compile ( ) {
2021-01-07 13:06:08 -05:00
let r = flags_from_vec ( svec! [
2020-11-30 14:35:12 -05:00
" deno " ,
" compile " ,
2023-12-01 21:20:06 -05:00
" https://examples.deno.land/color-logging.ts "
2020-11-30 14:35:12 -05:00
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Compile ( CompileFlags {
2023-12-01 21:20:06 -05:00
source_file : " https://examples.deno.land/color-logging.ts "
. to_string ( ) ,
2021-01-04 18:15:52 -05:00
output : None ,
args : vec ! [ ] ,
2021-01-18 21:40:22 -05:00
target : None ,
2023-07-28 11:46:26 -04:00
no_terminal : false ,
2023-03-18 19:43:07 -04:00
include : vec ! [ ]
2021-09-03 19:33:35 -04:00
} ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2020-11-30 14:35:12 -05:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn compile_with_flags ( ) {
#[ rustfmt::skip ]
2023-12-01 21:20:06 -05:00
let r = flags_from_vec ( svec! [ " deno " , " compile " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --unsafely-ignore-certificate-errors " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --location " , " https:foo " , " --allow-read " , " --allow-net " , " --v8-flags=--help " , " --seed " , " 1 " , " --no-terminal " , " --output " , " colors " , " --env=.example.env " , " https://examples.deno.land/color-logging.ts " , " foo " , " bar " , " -p " , " 8080 " ] ) ;
2020-11-30 14:35:12 -05:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Compile ( CompileFlags {
2023-12-01 21:20:06 -05:00
source_file : " https://examples.deno.land/color-logging.ts "
. to_string ( ) ,
2021-01-04 18:15:52 -05:00
output : Some ( PathBuf ::from ( " colors " ) ) ,
2023-09-08 13:14:59 -04:00
args : svec ! [ " foo " , " bar " , " -p " , " 8080 " ] ,
2021-01-18 21:40:22 -05:00
target : None ,
2023-07-28 11:46:26 -04:00
no_terminal : true ,
2023-03-18 19:43:07 -04:00
include : vec ! [ ]
2021-09-03 19:33:35 -04:00
} ) ,
2020-11-30 14:35:12 -05:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 19:12:51 -04:00
type_check_mode : TypeCheckMode ::None ,
2020-11-30 14:35:12 -05:00
reload : true ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
lock_write : true ,
2023-01-17 19:18:24 -05:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2021-01-04 18:15:52 -05:00
cached_only : true ,
2021-01-07 13:06:08 -05:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2021-01-04 18:15:52 -05:00
allow_read : Some ( vec! [ ] ) ,
2021-08-10 07:19:45 -04:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2021-01-04 18:15:52 -05:00
allow_net : Some ( vec! [ ] ) ,
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
seed : Some ( 1 ) ,
2023-11-01 11:21:13 -04:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
2020-11-30 14:35:12 -05:00
.. Flags ::default ( )
}
) ;
}
2021-01-23 20:18:19 -05:00
2021-02-24 09:27:51 -05:00
#[ test ]
fn coverage ( ) {
let r = flags_from_vec ( svec! [ " deno " , " coverage " , " foo.json " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 19:33:35 -04:00
subcommand : DenoSubcommand ::Coverage ( CoverageFlags {
2023-01-13 16:56:29 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " foo.json " . to_string ( ) ] ,
2023-01-13 16:56:29 -05:00
ignore : vec ! [ ] ,
} ,
2021-02-24 09:27:51 -05:00
include : vec ! [ r "^file:" . to_string ( ) ] ,
exclude : vec ! [ r "test\.(js|mjs|ts|jsx|tsx)$" . to_string ( ) ] ,
2023-12-18 05:48:45 -05:00
.. CoverageFlags ::default ( )
2021-09-03 19:33:35 -04:00
} ) ,
2021-02-24 09:27:51 -05:00
.. Flags ::default ( )
}
) ;
}
2022-02-15 10:33:21 -05:00
#[ test ]
fn coverage_with_lcov_and_out_file ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" coverage " ,
" --lcov " ,
" --output=foo.lcov " ,
" foo.json "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Coverage ( CoverageFlags {
2023-01-13 16:56:29 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " foo.json " . to_string ( ) ] ,
2023-01-13 16:56:29 -05:00
ignore : vec ! [ ] ,
} ,
2022-02-15 10:33:21 -05:00
include : vec ! [ r "^file:" . to_string ( ) ] ,
exclude : vec ! [ r "test\.(js|mjs|ts|jsx|tsx)$" . to_string ( ) ] ,
2023-12-08 02:54:52 -05:00
r#type : CoverageType ::Lcov ,
2022-02-15 10:33:21 -05:00
output : Some ( PathBuf ::from ( " foo.lcov " ) ) ,
} ) ,
.. Flags ::default ( )
}
) ;
}
2023-12-18 05:48:45 -05:00
#[ test ]
fn coverage_with_default_files ( ) {
let r = flags_from_vec ( svec! [ " deno " , " coverage " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Coverage ( CoverageFlags {
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " coverage " . to_string ( ) ] ,
2023-12-18 05:48:45 -05:00
ignore : vec ! [ ] ,
} ,
include : vec ! [ r "^file:" . to_string ( ) ] ,
exclude : vec ! [ r "test\.(js|mjs|ts|jsx|tsx)$" . to_string ( ) ] ,
.. CoverageFlags ::default ( )
} ) ,
.. Flags ::default ( )
}
) ;
}
2021-01-23 20:18:19 -05:00
#[ test ]
fn location_with_bad_scheme ( ) {
#[ rustfmt::skip ]
let r = flags_from_vec ( svec! [ " deno " , " run " , " --location " , " foo: " , " mod.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
assert! ( r
. unwrap_err ( )
. to_string ( )
. contains ( " Expected protocol \" http \" or \" https \" " ) ) ;
}
2021-10-04 19:35:55 -04:00
2022-01-17 20:10:17 -05:00
#[ test ]
fn test_config_path_args ( ) {
let flags = flags_from_vec ( svec! [ " deno " , " run " , " foo.js " ] ) . unwrap ( ) ;
2023-03-13 21:12:09 -04:00
let cwd = std ::env ::current_dir ( ) . unwrap ( ) ;
assert_eq! ( flags . config_path_args ( & cwd ) , Some ( vec! [ cwd . join ( " foo.js " ) ] ) ) ;
2022-01-17 20:10:17 -05:00
2022-02-25 00:39:18 -05:00
let flags =
flags_from_vec ( svec! [ " deno " , " run " , " https://example.com/foo.js " ] )
. unwrap ( ) ;
2023-03-13 21:12:09 -04:00
assert_eq! ( flags . config_path_args ( & cwd ) , None ) ;
2022-02-25 00:39:18 -05:00
2022-01-17 20:10:17 -05:00
let flags =
flags_from_vec ( svec! [ " deno " , " lint " , " dir/a.js " , " dir/b.js " ] ) . unwrap ( ) ;
assert_eq! (
2023-03-13 21:12:09 -04:00
flags . config_path_args ( & cwd ) ,
2024-01-15 19:15:39 -05:00
Some ( vec! [ cwd . join ( " dir/a.js " ) , cwd . join ( " dir/b.js " ) ] )
2022-01-17 20:10:17 -05:00
) ;
let flags = flags_from_vec ( svec! [ " deno " , " lint " ] ) . unwrap ( ) ;
2023-03-13 21:12:09 -04:00
assert! ( flags . config_path_args ( & cwd ) . unwrap ( ) . is_empty ( ) ) ;
2022-01-17 20:10:17 -05:00
let flags =
flags_from_vec ( svec! [ " deno " , " fmt " , " dir/a.js " , " dir/b.js " ] ) . unwrap ( ) ;
assert_eq! (
2023-03-13 21:12:09 -04:00
flags . config_path_args ( & cwd ) ,
2024-01-15 19:15:39 -05:00
Some ( vec! [ cwd . join ( " dir/a.js " ) , cwd . join ( " dir/b.js " ) ] )
2022-01-17 20:10:17 -05:00
) ;
}
2022-01-31 11:39:39 -05:00
#[ test ]
fn test_no_clear_watch_flag_without_watch_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-clear-screen " , " foo.js " ] ) ;
assert! ( r . is_err ( ) ) ;
let error_message = r . unwrap_err ( ) . to_string ( ) ;
assert! ( & error_message
2023-03-26 00:06:18 -04:00
. contains ( " error: the following required arguments were not provided: " ) ) ;
2022-03-27 21:57:56 -04:00
assert! ( & error_message . contains ( " --watch[=<FILES>...] " ) ) ;
2022-01-31 11:39:39 -05:00
}
2022-02-16 13:14:19 -05:00
#[ test ]
fn vendor_minimal ( ) {
let r = flags_from_vec ( svec! [ " deno " , " vendor " , " mod.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Vendor ( VendorFlags {
specifiers : svec ! [ " mod.ts " ] ,
force : false ,
output_path : None ,
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn vendor_all ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" vendor " ,
" --config " ,
" deno.json " ,
" --import-map " ,
" import_map.json " ,
" --lock " ,
" lock.json " ,
" --force " ,
" --output " ,
" out_dir " ,
" --reload " ,
" mod.ts " ,
" deps.test.ts " ,
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Vendor ( VendorFlags {
specifiers : svec ! [ " mod.ts " , " deps.test.ts " ] ,
force : true ,
output_path : Some ( PathBuf ::from ( " out_dir " ) ) ,
} ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " deno.json " . to_owned ( ) ) ,
2022-02-16 13:14:19 -05:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
reload : true ,
.. Flags ::default ( )
}
) ;
}
2022-03-10 20:56:14 -05:00
#[ test ]
fn task_subcommand ( ) {
2022-04-27 15:43:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " hello " , " world " , ] ) ;
2022-03-10 20:56:14 -05:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-03-10 20:56:14 -05:00
} ) ,
argv : svec ! [ " hello " , " world " ] ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-06-08 17:30:16 -04:00
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " task " , " --cwd " , " foo " , " build " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
cwd : Some ( " foo " . to_string ( ) ) ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-03-10 20:56:14 -05:00
} ) ,
.. Flags ::default ( )
}
) ;
}
2022-04-27 15:43:36 -04:00
#[ test ]
fn task_subcommand_double_hyphen ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" task " ,
" -c " ,
" deno.json " ,
" build " ,
" -- " ,
" hello " ,
" world " ,
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-04-27 15:43:36 -04:00
} ) ,
argv : svec ! [ " -- " , " hello " , " world " ] ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " deno.json " . to_owned ( ) ) ,
2022-04-27 15:43:36 -04:00
.. Flags ::default ( )
2022-04-29 19:51:10 -04:00
}
) ;
2022-06-08 17:30:16 -04:00
let r = flags_from_vec ( svec! [
" deno " , " task " , " --cwd " , " foo " , " build " , " -- " , " hello " , " world "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
cwd : Some ( " foo " . to_string ( ) ) ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-06-08 17:30:16 -04:00
} ) ,
argv : svec ! [ " -- " , " hello " , " world " ] ,
.. Flags ::default ( )
}
) ;
2022-04-29 19:51:10 -04:00
}
#[ test ]
fn task_subcommand_double_hyphen_only ( ) {
// edge case, but it should forward
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " -- " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-04-29 19:51:10 -04:00
} ) ,
argv : svec ! [ " -- " ] ,
.. Flags ::default ( )
2022-04-27 15:43:36 -04:00
}
) ;
}
2022-04-29 10:29:14 -04:00
#[ test ]
fn task_following_arg ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " -1 " , " --test " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-04-29 10:29:14 -04:00
} ) ,
argv : svec ! [ " -1 " , " --test " ] ,
.. Flags ::default ( )
}
) ;
}
2022-05-11 12:58:35 -04:00
#[ test ]
fn task_following_double_hyphen_arg ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " --test " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-05-11 12:58:35 -04:00
} ) ,
argv : svec ! [ " --test " ] ,
.. Flags ::default ( )
}
) ;
}
2022-08-10 11:55:34 -04:00
#[ test ]
fn task_with_global_flags ( ) {
// can fail if the custom parser in task_parse() starts at the wrong index
let r =
flags_from_vec ( svec! [ " deno " , " --quiet " , " --unstable " , " task " , " build " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
cwd : None ,
2023-02-22 22:45:35 -05:00
task : Some ( " build " . to_string ( ) ) ,
2022-08-10 11:55:34 -04:00
} ) ,
unstable : true ,
log_level : Some ( log ::Level ::Error ) ,
.. Flags ::default ( )
}
) ;
}
2022-03-10 20:56:14 -05:00
#[ test ]
fn task_subcommand_empty ( ) {
2022-04-27 15:43:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " task " ] ) ;
2022-03-10 20:56:14 -05:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : None ,
2022-03-10 20:56:14 -05:00
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn task_subcommand_config ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " --config " , " deno.jsonc " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : None ,
2022-03-10 20:56:14 -05:00
} ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2022-03-10 20:56:14 -05:00
.. Flags ::default ( )
}
2022-05-11 12:58:35 -04:00
) ;
}
#[ test ]
fn task_subcommand_config_short ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " -c " , " deno.jsonc " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 17:30:16 -04:00
cwd : None ,
2023-02-22 22:45:35 -05:00
task : None ,
2022-05-11 12:58:35 -04:00
} ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2022-05-11 12:58:35 -04:00
.. Flags ::default ( )
}
2022-03-10 20:56:14 -05:00
) ;
}
2022-03-11 17:07:02 -05:00
2022-06-28 15:47:51 -04:00
#[ test ]
fn task_subcommand_noconfig_invalid ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " --no-config " ] ) ;
2023-03-26 00:06:18 -04:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::UnknownArgument
) ;
2022-06-28 15:47:51 -04:00
}
2022-03-11 17:07:02 -05:00
#[ test ]
fn bench_with_flags ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" bench " ,
2023-02-12 12:40:45 -05:00
" --json " ,
2022-03-11 17:07:02 -05:00
" --unstable " ,
2023-03-13 17:04:00 -04:00
" --no-npm " ,
" --no-remote " ,
2023-03-26 10:55:58 -04:00
" --no-run " ,
2022-03-11 17:07:02 -05:00
" --filter " ,
" - foo " ,
" --location " ,
" https:foo " ,
" --allow-net " ,
" dir1/ " ,
" dir2/ " ,
" -- " ,
" arg1 " ,
" arg2 "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Bench ( BenchFlags {
filter : Some ( " - foo " . to_string ( ) ) ,
2023-02-12 12:40:45 -05:00
json : true ,
2023-03-26 10:55:58 -04:00
no_run : true ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
2024-01-15 19:15:39 -05:00
include : vec ! [ " dir1/ " . to_string ( ) , " dir2/ " . to_string ( ) ] ,
2023-01-07 15:22:09 -05:00
ignore : vec ! [ ] ,
} ,
2023-06-15 13:09:37 -04:00
watch : Default ::default ( ) ,
2022-03-11 17:07:02 -05:00
} ) ,
unstable : true ,
2023-03-13 17:04:00 -04:00
no_npm : true ,
no_remote : true ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-03-11 17:07:02 -05:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
allow_net : Some ( vec! [ ] ) ,
no_prompt : true ,
argv : svec ! [ " arg1 " , " arg2 " ] ,
.. Flags ::default ( )
}
) ;
}
2022-04-10 19:12:51 -04:00
2023-01-07 15:22:09 -05:00
#[ test ]
fn bench_watch ( ) {
let r = flags_from_vec ( svec! [ " deno " , " bench " , " --watch " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Bench ( BenchFlags {
filter : None ,
2023-02-12 12:40:45 -05:00
json : false ,
2023-03-26 10:55:58 -04:00
no_run : false ,
2023-01-07 15:22:09 -05:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2023-10-30 20:25:58 -04:00
watch : Some ( Default ::default ( ) ) ,
2023-01-07 15:22:09 -05:00
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
}
) ;
}
2022-04-10 19:12:51 -04:00
#[ test ]
fn run_with_check ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --check " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::Local ,
2022-04-10 19:12:51 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --check=all " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::All ,
2022-04-10 19:12:51 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --check=foo " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-06-13 17:13:16 -04:00
type_check_mode : TypeCheckMode ::None ,
2022-04-10 19:12:51 -04:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --no-check " ,
" --check " ,
" script.ts " ,
] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-05-13 11:40:50 -04:00
#[ test ]
fn no_config ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-config " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 16:36:06 -05:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-05-13 11:40:50 -04:00
config_flag : ConfigFlag ::Disabled ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --config " ,
" deno.json " ,
" --no-config " ,
" script.ts " ,
] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-08-19 19:37:05 -04:00
#[ test ]
fn init ( ) {
let r = flags_from_vec ( svec! [ " deno " , " init " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Init ( InitFlags { dir : None } ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " init " , " foo " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Init ( InitFlags {
dir : Some ( String ::from ( " foo " ) ) ,
} ) ,
.. Flags ::default ( )
}
) ;
2022-09-02 11:59:36 -04:00
let r = flags_from_vec ( svec! [ " deno " , " init " , " --quiet " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Init ( InitFlags { dir : None } ) ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
2022-08-19 19:37:05 -04:00
}
2023-09-15 20:42:09 -04:00
#[ test ]
fn jupyter ( ) {
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --unstable " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Jupyter ( JupyterFlags {
install : false ,
kernel : false ,
conn_file : None ,
} ) ,
unstable : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --unstable " , " --install " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Jupyter ( JupyterFlags {
install : true ,
kernel : false ,
conn_file : None ,
} ) ,
unstable : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" jupyter " ,
" --unstable " ,
" --kernel " ,
" --conn " ,
" path/to/conn/file "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Jupyter ( JupyterFlags {
install : false ,
kernel : true ,
conn_file : Some ( PathBuf ::from ( " path/to/conn/file " ) ) ,
} ) ,
unstable : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" jupyter " ,
" --install " ,
" --conn " ,
" path/to/conn/file "
] ) ;
r . unwrap_err ( ) ;
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --kernel " , ] ) ;
r . unwrap_err ( ) ;
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --install " , " --kernel " , ] ) ;
r . unwrap_err ( ) ;
}
2020-03-27 16:09:51 -04:00
}