jn
/
punkshell
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

punk::path fix for unix systems, silence enableRaw_stty

master
Julian Noble 2 weeks ago
parent
d6d6ea8de5
commit
6db4bfa15f
15 changed files with 245 additions and 95 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 50
      src/bootsupport/modules/punk-0.1.tm
  2. 2
      src/bootsupport/modules/punk/console-0.1.1.tm
  3. 16
      src/bootsupport/modules/textblock-0.1.3.tm
  4. 50
      src/modules/punk-0.1.tm
  5. 2
      src/modules/punk/console-999999.0a1.0.tm
  6. 16
      src/modules/textblock-999999.0a1.0.tm
  7. 50
      src/project_layouts/custom/_project/punk.project-0.1/src/bootsupport/modules/punk-0.1.tm
  8. 2
      src/project_layouts/custom/_project/punk.project-0.1/src/bootsupport/modules/punk/console-0.1.1.tm
  9. 16
      src/project_layouts/custom/_project/punk.project-0.1/src/bootsupport/modules/textblock-0.1.3.tm
  10. 50
      src/project_layouts/custom/_project/punk.shell-0.1/src/bootsupport/modules/punk-0.1.tm
  11. 2
      src/project_layouts/custom/_project/punk.shell-0.1/src/bootsupport/modules/punk/console-0.1.1.tm
  12. 16
      src/project_layouts/custom/_project/punk.shell-0.1/src/bootsupport/modules/textblock-0.1.3.tm
  13. 50
      src/vfs/_vfscommon.vfs/modules/punk-0.1.tm
  14. 2
      src/vfs/_vfscommon.vfs/modules/punk/console-0.1.1.tm
  15. 16
      src/vfs/_vfscommon.vfs/modules/textblock-0.1.3.tm

50
src/bootsupport/modules/punk-0.1.tm
Unescape View File

@ -6326,7 +6326,7 @@ namespace eval punk {
lassign [dict values $argd] leaders opts values received lassign [dict values $argd] leaders opts values received
set pathglobs [dict get $opts -pathglob] set pathglobs [dict get $opts -pathglob]
set binglobs [dict get $values binglob] set binglobs [dict get $values binglob]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set sep ";" set sep ";"
} else { } else {
# : ok for linux/bsd ... mac? # : ok for linux/bsd ... mac?
@ -6386,6 +6386,7 @@ namespace eval punk {
#Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable. #Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable.
#We need to account for this in our glob pattern. #We need to account for this in our glob pattern.
set pathexts [list] set pathexts [list]
#review - we assume this is only relevant on windows for now.
if {[info exists ::env(PATHEXT)]} { if {[info exists ::env(PATHEXT)]} {
set env_pathexts [split $::env(PATHEXT) ";"] set env_pathexts [split $::env(PATHEXT) ";"]
#set pathexts [lmap e $env_pathexts {string tolower $e}] #set pathexts [lmap e $env_pathexts {string tolower $e}]
@ -6442,7 +6443,7 @@ namespace eval punk {
set d_index_executables [dict create] ;#key is path index, value is list of executables in that path set d_index_executables [dict create] ;#key is path index, value is list of executables in that path
set path_idx 0 set path_idx 0
foreach p $all_paths { foreach p $all_paths {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set pnorm [string tolower $p] set pnorm [string tolower $p]
} else { } else {
set pnorm $p set pnorm $p
@ -6461,7 +6462,7 @@ namespace eval punk {
#If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names. #If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names.
#also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct. #also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct.
set pnormglob [file normalize $p] set pnormglob [file normalize $p]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
#TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem. #TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem.
#(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug) #(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug)
@ -6501,7 +6502,7 @@ namespace eval punk {
dict set d_index_executables $path_idx $executables dict set d_index_executables $path_idx $executables
foreach exe $executables { foreach exe $executables {
#todo - other case-insensitive platforms/filesystems. #todo - other case-insensitive platforms/filesystems.
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
#on case #on case
@ -6533,7 +6534,7 @@ namespace eval punk {
#However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables. #However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables.
set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path
foreach exe $executables { foreach exe $executables {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
set exe_key $exe set exe_key $exe
@ -6596,7 +6597,11 @@ namespace eval punk {
# continue # continue
#} #}
set thisrow [list $pidx] set thisrow [list $pidx]
set pnorm [string tolower $p] if {$is_windows} {
set pnorm [string tolower $p]
} else {
set pnorm $p
}
if {[string length $pnorm] > 1} { if {[string length $pnorm] > 1} {
set lastchar [string index $pnorm end] set lastchar [string index $pnorm end]
if {$lastchar eq "/" || $lastchar eq "\\"} { if {$lastchar eq "/" || $lastchar eq "\\"} {
@ -6617,15 +6622,28 @@ namespace eval punk {
set display_executables [list] set display_executables [list]
foreach exe $executables { foreach exe $executables {
set matched_binglob 0 set matched_binglob 0
foreach bg $binglobs { if {$is_windows} {
#review - -nocase only on case-insensitive platforms/filesystems? foreach bg $binglobs {
#- but it is simpler to just apply it to all platforms here rather than trying to determine case-sensitivity of each path. #review - -nocase only on case-insensitive platforms/filesystems?
if {[string match -nocase $bg $exe]} { #todo - mac has case-insensitive filesystem by default.
set matched_binglob 1 if {[string match -nocase $bg $exe]} {
continue set matched_binglob 1
continue
}
}
} else {
foreach bg $binglobs {
if {[string match $bg $exe]} {
set matched_binglob 1
continue
}
} }
} }
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]
@ -6738,7 +6756,11 @@ namespace eval punk {
set executables [dict get $d_index_executables $original_path_idx] set executables [dict get $d_index_executables $original_path_idx]
lappend thisrow [llength $executables] lappend thisrow [llength $executables]
foreach exe $executables { foreach exe $executables {
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]

2
src/bootsupport/modules/punk/console-0.1.1.tm
Unescape View File

@ -3634,7 +3634,7 @@ namespace eval punk::console::system {
catch { catch {
chan configure stdin -inputmode raw chan configure stdin -inputmode raw
} }
puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]" #puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]"
return [dict create previous [set previous_stty_state_$channel]] return [dict create previous [set previous_stty_state_$channel]]
} }
proc disableRaw_stty {{channel stdin}} { proc disableRaw_stty {{channel stdin}} {

16
src/bootsupport/modules/textblock-0.1.3.tm
Unescape View File

@ -5751,8 +5751,13 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
see also textblock::join_basic_raw - a thin wrapper around split and join for the common case of joining blocks without any options, see also textblock::join_basic_raw - a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks
and is intended to avoid the overhead of argument parsing. without any options, and is intended to avoid the minor additional overhead of argument parsing.
For both, -ansireplays is always on (if ansi detected) and -ansiresets defaults to auto which means we will add resets at the start
and end of each line if we detect any ansi codes in the block, but won't add them if we don't detect any ansi codes in the block.
This is because joined blocks often have adjacent lines with no padding between them, so without resets at line extremes
- trailing ansi from one block's line can easily affect the corresponding line in the next block.
" "
-ansiresets -type any -default auto -ansiresets -type any -default auto
-- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags" -- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags"
@ -5804,8 +5809,11 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
This version is a thin wrapper around split and join for the common case of joining blocks without any options, This version is a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks without
and is intended to avoid the overhead of argument parsing. any options, and is intended to avoid the minor additional overhead of argument parsing.
The performance is dominated by the ansireplays processing when ansi is detected, and this will be the same for
textblock::join_basic, textblock::join_basic_raw and textblock::join.
" "
@values @values
blocks -type any -multiple 1 blocks -type any -multiple 1

50
src/modules/punk-0.1.tm
Unescape View File

@ -6326,7 +6326,7 @@ namespace eval punk {
lassign [dict values $argd] leaders opts values received lassign [dict values $argd] leaders opts values received
set pathglobs [dict get $opts -pathglob] set pathglobs [dict get $opts -pathglob]
set binglobs [dict get $values binglob] set binglobs [dict get $values binglob]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set sep ";" set sep ";"
} else { } else {
# : ok for linux/bsd ... mac? # : ok for linux/bsd ... mac?
@ -6386,6 +6386,7 @@ namespace eval punk {
#Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable. #Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable.
#We need to account for this in our glob pattern. #We need to account for this in our glob pattern.
set pathexts [list] set pathexts [list]
#review - we assume this is only relevant on windows for now.
if {[info exists ::env(PATHEXT)]} { if {[info exists ::env(PATHEXT)]} {
set env_pathexts [split $::env(PATHEXT) ";"] set env_pathexts [split $::env(PATHEXT) ";"]
#set pathexts [lmap e $env_pathexts {string tolower $e}] #set pathexts [lmap e $env_pathexts {string tolower $e}]
@ -6442,7 +6443,7 @@ namespace eval punk {
set d_index_executables [dict create] ;#key is path index, value is list of executables in that path set d_index_executables [dict create] ;#key is path index, value is list of executables in that path
set path_idx 0 set path_idx 0
foreach p $all_paths { foreach p $all_paths {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set pnorm [string tolower $p] set pnorm [string tolower $p]
} else { } else {
set pnorm $p set pnorm $p
@ -6461,7 +6462,7 @@ namespace eval punk {
#If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names. #If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names.
#also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct. #also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct.
set pnormglob [file normalize $p] set pnormglob [file normalize $p]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
#TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem. #TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem.
#(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug) #(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug)
@ -6501,7 +6502,7 @@ namespace eval punk {
dict set d_index_executables $path_idx $executables dict set d_index_executables $path_idx $executables
foreach exe $executables { foreach exe $executables {
#todo - other case-insensitive platforms/filesystems. #todo - other case-insensitive platforms/filesystems.
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
#on case #on case
@ -6533,7 +6534,7 @@ namespace eval punk {
#However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables. #However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables.
set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path
foreach exe $executables { foreach exe $executables {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
set exe_key $exe set exe_key $exe
@ -6596,7 +6597,11 @@ namespace eval punk {
# continue # continue
#} #}
set thisrow [list $pidx] set thisrow [list $pidx]
set pnorm [string tolower $p] if {$is_windows} {
set pnorm [string tolower $p]
} else {
set pnorm $p
}
if {[string length $pnorm] > 1} { if {[string length $pnorm] > 1} {
set lastchar [string index $pnorm end] set lastchar [string index $pnorm end]
if {$lastchar eq "/" || $lastchar eq "\\"} { if {$lastchar eq "/" || $lastchar eq "\\"} {
@ -6617,15 +6622,28 @@ namespace eval punk {
set display_executables [list] set display_executables [list]
foreach exe $executables { foreach exe $executables {
set matched_binglob 0 set matched_binglob 0
foreach bg $binglobs { if {$is_windows} {
#review - -nocase only on case-insensitive platforms/filesystems? foreach bg $binglobs {
#- but it is simpler to just apply it to all platforms here rather than trying to determine case-sensitivity of each path. #review - -nocase only on case-insensitive platforms/filesystems?
if {[string match -nocase $bg $exe]} { #todo - mac has case-insensitive filesystem by default.
set matched_binglob 1 if {[string match -nocase $bg $exe]} {
continue set matched_binglob 1
continue
}
}
} else {
foreach bg $binglobs {
if {[string match $bg $exe]} {
set matched_binglob 1
continue
}
} }
} }
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]
@ -6738,7 +6756,11 @@ namespace eval punk {
set executables [dict get $d_index_executables $original_path_idx] set executables [dict get $d_index_executables $original_path_idx]
lappend thisrow [llength $executables] lappend thisrow [llength $executables]
foreach exe $executables { foreach exe $executables {
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]

2
src/modules/punk/console-999999.0a1.0.tm
Unescape View File

@ -3634,7 +3634,7 @@ namespace eval punk::console::system {
catch { catch {
chan configure stdin -inputmode raw chan configure stdin -inputmode raw
} }
puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]" #puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]"
return [dict create previous [set previous_stty_state_$channel]] return [dict create previous [set previous_stty_state_$channel]]
} }
proc disableRaw_stty {{channel stdin}} { proc disableRaw_stty {{channel stdin}} {

16
src/modules/textblock-999999.0a1.0.tm
Unescape View File

@ -5751,8 +5751,13 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
see also textblock::join_basic_raw - a thin wrapper around split and join for the common case of joining blocks without any options, see also textblock::join_basic_raw - a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks
and is intended to avoid the overhead of argument parsing. without any options, and is intended to avoid the minor additional overhead of argument parsing.
For both, -ansireplays is always on (if ansi detected) and -ansiresets defaults to auto which means we will add resets at the start
and end of each line if we detect any ansi codes in the block, but won't add them if we don't detect any ansi codes in the block.
This is because joined blocks often have adjacent lines with no padding between them, so without resets at line extremes
- trailing ansi from one block's line can easily affect the corresponding line in the next block.
" "
-ansiresets -type any -default auto -ansiresets -type any -default auto
-- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags" -- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags"
@ -5804,8 +5809,11 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
This version is a thin wrapper around split and join for the common case of joining blocks without any options, This version is a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks without
and is intended to avoid the overhead of argument parsing. any options, and is intended to avoid the minor additional overhead of argument parsing.
The performance is dominated by the ansireplays processing when ansi is detected, and this will be the same for
textblock::join_basic, textblock::join_basic_raw and textblock::join.
" "
@values @values
blocks -type any -multiple 1 blocks -type any -multiple 1

50
src/project_layouts/custom/_project/punk.project-0.1/src/bootsupport/modules/punk-0.1.tm
Unescape View File

@ -6326,7 +6326,7 @@ namespace eval punk {
lassign [dict values $argd] leaders opts values received lassign [dict values $argd] leaders opts values received
set pathglobs [dict get $opts -pathglob] set pathglobs [dict get $opts -pathglob]
set binglobs [dict get $values binglob] set binglobs [dict get $values binglob]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set sep ";" set sep ";"
} else { } else {
# : ok for linux/bsd ... mac? # : ok for linux/bsd ... mac?
@ -6386,6 +6386,7 @@ namespace eval punk {
#Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable. #Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable.
#We need to account for this in our glob pattern. #We need to account for this in our glob pattern.
set pathexts [list] set pathexts [list]
#review - we assume this is only relevant on windows for now.
if {[info exists ::env(PATHEXT)]} { if {[info exists ::env(PATHEXT)]} {
set env_pathexts [split $::env(PATHEXT) ";"] set env_pathexts [split $::env(PATHEXT) ";"]
#set pathexts [lmap e $env_pathexts {string tolower $e}] #set pathexts [lmap e $env_pathexts {string tolower $e}]
@ -6442,7 +6443,7 @@ namespace eval punk {
set d_index_executables [dict create] ;#key is path index, value is list of executables in that path set d_index_executables [dict create] ;#key is path index, value is list of executables in that path
set path_idx 0 set path_idx 0
foreach p $all_paths { foreach p $all_paths {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set pnorm [string tolower $p] set pnorm [string tolower $p]
} else { } else {
set pnorm $p set pnorm $p
@ -6461,7 +6462,7 @@ namespace eval punk {
#If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names. #If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names.
#also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct. #also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct.
set pnormglob [file normalize $p] set pnormglob [file normalize $p]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
#TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem. #TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem.
#(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug) #(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug)
@ -6501,7 +6502,7 @@ namespace eval punk {
dict set d_index_executables $path_idx $executables dict set d_index_executables $path_idx $executables
foreach exe $executables { foreach exe $executables {
#todo - other case-insensitive platforms/filesystems. #todo - other case-insensitive platforms/filesystems.
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
#on case #on case
@ -6533,7 +6534,7 @@ namespace eval punk {
#However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables. #However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables.
set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path
foreach exe $executables { foreach exe $executables {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
set exe_key $exe set exe_key $exe
@ -6596,7 +6597,11 @@ namespace eval punk {
# continue # continue
#} #}
set thisrow [list $pidx] set thisrow [list $pidx]
set pnorm [string tolower $p] if {$is_windows} {
set pnorm [string tolower $p]
} else {
set pnorm $p
}
if {[string length $pnorm] > 1} { if {[string length $pnorm] > 1} {
set lastchar [string index $pnorm end] set lastchar [string index $pnorm end]
if {$lastchar eq "/" || $lastchar eq "\\"} { if {$lastchar eq "/" || $lastchar eq "\\"} {
@ -6617,15 +6622,28 @@ namespace eval punk {
set display_executables [list] set display_executables [list]
foreach exe $executables { foreach exe $executables {
set matched_binglob 0 set matched_binglob 0
foreach bg $binglobs { if {$is_windows} {
#review - -nocase only on case-insensitive platforms/filesystems? foreach bg $binglobs {
#- but it is simpler to just apply it to all platforms here rather than trying to determine case-sensitivity of each path. #review - -nocase only on case-insensitive platforms/filesystems?
if {[string match -nocase $bg $exe]} { #todo - mac has case-insensitive filesystem by default.
set matched_binglob 1 if {[string match -nocase $bg $exe]} {
continue set matched_binglob 1
continue
}
}
} else {
foreach bg $binglobs {
if {[string match $bg $exe]} {
set matched_binglob 1
continue
}
} }
} }
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]
@ -6738,7 +6756,11 @@ namespace eval punk {
set executables [dict get $d_index_executables $original_path_idx] set executables [dict get $d_index_executables $original_path_idx]
lappend thisrow [llength $executables] lappend thisrow [llength $executables]
foreach exe $executables { foreach exe $executables {
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]

2
src/project_layouts/custom/_project/punk.project-0.1/src/bootsupport/modules/punk/console-0.1.1.tm
Unescape View File

@ -3634,7 +3634,7 @@ namespace eval punk::console::system {
catch { catch {
chan configure stdin -inputmode raw chan configure stdin -inputmode raw
} }
puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]" #puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]"
return [dict create previous [set previous_stty_state_$channel]] return [dict create previous [set previous_stty_state_$channel]]
} }
proc disableRaw_stty {{channel stdin}} { proc disableRaw_stty {{channel stdin}} {

16
src/project_layouts/custom/_project/punk.project-0.1/src/bootsupport/modules/textblock-0.1.3.tm
Unescape View File

@ -5751,8 +5751,13 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
see also textblock::join_basic_raw - a thin wrapper around split and join for the common case of joining blocks without any options, see also textblock::join_basic_raw - a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks
and is intended to avoid the overhead of argument parsing. without any options, and is intended to avoid the minor additional overhead of argument parsing.
For both, -ansireplays is always on (if ansi detected) and -ansiresets defaults to auto which means we will add resets at the start
and end of each line if we detect any ansi codes in the block, but won't add them if we don't detect any ansi codes in the block.
This is because joined blocks often have adjacent lines with no padding between them, so without resets at line extremes
- trailing ansi from one block's line can easily affect the corresponding line in the next block.
" "
-ansiresets -type any -default auto -ansiresets -type any -default auto
-- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags" -- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags"
@ -5804,8 +5809,11 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
This version is a thin wrapper around split and join for the common case of joining blocks without any options, This version is a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks without
and is intended to avoid the overhead of argument parsing. any options, and is intended to avoid the minor additional overhead of argument parsing.
The performance is dominated by the ansireplays processing when ansi is detected, and this will be the same for
textblock::join_basic, textblock::join_basic_raw and textblock::join.
" "
@values @values
blocks -type any -multiple 1 blocks -type any -multiple 1

50
src/project_layouts/custom/_project/punk.shell-0.1/src/bootsupport/modules/punk-0.1.tm
Unescape View File

@ -6326,7 +6326,7 @@ namespace eval punk {
lassign [dict values $argd] leaders opts values received lassign [dict values $argd] leaders opts values received
set pathglobs [dict get $opts -pathglob] set pathglobs [dict get $opts -pathglob]
set binglobs [dict get $values binglob] set binglobs [dict get $values binglob]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set sep ";" set sep ";"
} else { } else {
# : ok for linux/bsd ... mac? # : ok for linux/bsd ... mac?
@ -6386,6 +6386,7 @@ namespace eval punk {
#Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable. #Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable.
#We need to account for this in our glob pattern. #We need to account for this in our glob pattern.
set pathexts [list] set pathexts [list]
#review - we assume this is only relevant on windows for now.
if {[info exists ::env(PATHEXT)]} { if {[info exists ::env(PATHEXT)]} {
set env_pathexts [split $::env(PATHEXT) ";"] set env_pathexts [split $::env(PATHEXT) ";"]
#set pathexts [lmap e $env_pathexts {string tolower $e}] #set pathexts [lmap e $env_pathexts {string tolower $e}]
@ -6442,7 +6443,7 @@ namespace eval punk {
set d_index_executables [dict create] ;#key is path index, value is list of executables in that path set d_index_executables [dict create] ;#key is path index, value is list of executables in that path
set path_idx 0 set path_idx 0
foreach p $all_paths { foreach p $all_paths {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set pnorm [string tolower $p] set pnorm [string tolower $p]
} else { } else {
set pnorm $p set pnorm $p
@ -6461,7 +6462,7 @@ namespace eval punk {
#If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names. #If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names.
#also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct. #also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct.
set pnormglob [file normalize $p] set pnormglob [file normalize $p]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
#TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem. #TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem.
#(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug) #(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug)
@ -6501,7 +6502,7 @@ namespace eval punk {
dict set d_index_executables $path_idx $executables dict set d_index_executables $path_idx $executables
foreach exe $executables { foreach exe $executables {
#todo - other case-insensitive platforms/filesystems. #todo - other case-insensitive platforms/filesystems.
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
#on case #on case
@ -6533,7 +6534,7 @@ namespace eval punk {
#However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables. #However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables.
set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path
foreach exe $executables { foreach exe $executables {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
set exe_key $exe set exe_key $exe
@ -6596,7 +6597,11 @@ namespace eval punk {
# continue # continue
#} #}
set thisrow [list $pidx] set thisrow [list $pidx]
set pnorm [string tolower $p] if {$is_windows} {
set pnorm [string tolower $p]
} else {
set pnorm $p
}
if {[string length $pnorm] > 1} { if {[string length $pnorm] > 1} {
set lastchar [string index $pnorm end] set lastchar [string index $pnorm end]
if {$lastchar eq "/" || $lastchar eq "\\"} { if {$lastchar eq "/" || $lastchar eq "\\"} {
@ -6617,15 +6622,28 @@ namespace eval punk {
set display_executables [list] set display_executables [list]
foreach exe $executables { foreach exe $executables {
set matched_binglob 0 set matched_binglob 0
foreach bg $binglobs { if {$is_windows} {
#review - -nocase only on case-insensitive platforms/filesystems? foreach bg $binglobs {
#- but it is simpler to just apply it to all platforms here rather than trying to determine case-sensitivity of each path. #review - -nocase only on case-insensitive platforms/filesystems?
if {[string match -nocase $bg $exe]} { #todo - mac has case-insensitive filesystem by default.
set matched_binglob 1 if {[string match -nocase $bg $exe]} {
continue set matched_binglob 1
continue
}
}
} else {
foreach bg $binglobs {
if {[string match $bg $exe]} {
set matched_binglob 1
continue
}
} }
} }
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]
@ -6738,7 +6756,11 @@ namespace eval punk {
set executables [dict get $d_index_executables $original_path_idx] set executables [dict get $d_index_executables $original_path_idx]
lappend thisrow [llength $executables] lappend thisrow [llength $executables]
foreach exe $executables { foreach exe $executables {
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]

2
src/project_layouts/custom/_project/punk.shell-0.1/src/bootsupport/modules/punk/console-0.1.1.tm
Unescape View File

@ -3634,7 +3634,7 @@ namespace eval punk::console::system {
catch { catch {
chan configure stdin -inputmode raw chan configure stdin -inputmode raw
} }
puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]" #puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]"
return [dict create previous [set previous_stty_state_$channel]] return [dict create previous [set previous_stty_state_$channel]]
} }
proc disableRaw_stty {{channel stdin}} { proc disableRaw_stty {{channel stdin}} {

16
src/project_layouts/custom/_project/punk.shell-0.1/src/bootsupport/modules/textblock-0.1.3.tm
Unescape View File

@ -5751,8 +5751,13 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
see also textblock::join_basic_raw - a thin wrapper around split and join for the common case of joining blocks without any options, see also textblock::join_basic_raw - a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks
and is intended to avoid the overhead of argument parsing. without any options, and is intended to avoid the minor additional overhead of argument parsing.
For both, -ansireplays is always on (if ansi detected) and -ansiresets defaults to auto which means we will add resets at the start
and end of each line if we detect any ansi codes in the block, but won't add them if we don't detect any ansi codes in the block.
This is because joined blocks often have adjacent lines with no padding between them, so without resets at line extremes
- trailing ansi from one block's line can easily affect the corresponding line in the next block.
" "
-ansiresets -type any -default auto -ansiresets -type any -default auto
-- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags" -- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags"
@ -5804,8 +5809,11 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
This version is a thin wrapper around split and join for the common case of joining blocks without any options, This version is a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks without
and is intended to avoid the overhead of argument parsing. any options, and is intended to avoid the minor additional overhead of argument parsing.
The performance is dominated by the ansireplays processing when ansi is detected, and this will be the same for
textblock::join_basic, textblock::join_basic_raw and textblock::join.
" "
@values @values
blocks -type any -multiple 1 blocks -type any -multiple 1

50
src/vfs/_vfscommon.vfs/modules/punk-0.1.tm
Unescape View File

@ -6326,7 +6326,7 @@ namespace eval punk {
lassign [dict values $argd] leaders opts values received lassign [dict values $argd] leaders opts values received
set pathglobs [dict get $opts -pathglob] set pathglobs [dict get $opts -pathglob]
set binglobs [dict get $values binglob] set binglobs [dict get $values binglob]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set sep ";" set sep ";"
} else { } else {
# : ok for linux/bsd ... mac? # : ok for linux/bsd ... mac?
@ -6386,6 +6386,7 @@ namespace eval punk {
#Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable. #Sometimes PATHEXT includes an entry of just a dot - which means files with no extension are considered executable.
#We need to account for this in our glob pattern. #We need to account for this in our glob pattern.
set pathexts [list] set pathexts [list]
#review - we assume this is only relevant on windows for now.
if {[info exists ::env(PATHEXT)]} { if {[info exists ::env(PATHEXT)]} {
set env_pathexts [split $::env(PATHEXT) ";"] set env_pathexts [split $::env(PATHEXT) ";"]
#set pathexts [lmap e $env_pathexts {string tolower $e}] #set pathexts [lmap e $env_pathexts {string tolower $e}]
@ -6442,7 +6443,7 @@ namespace eval punk {
set d_index_executables [dict create] ;#key is path index, value is list of executables in that path set d_index_executables [dict create] ;#key is path index, value is list of executables in that path
set path_idx 0 set path_idx 0
foreach p $all_paths { foreach p $all_paths {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set pnorm [string tolower $p] set pnorm [string tolower $p]
} else { } else {
set pnorm $p set pnorm $p
@ -6461,7 +6462,7 @@ namespace eval punk {
#If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names. #If we don't normalize the path here - then trailing backslashes on windows can cause a problem with the -tail glob returning a leading slash on the executable names.
#also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct. #also as we don't necessarily normalize the resulting final path with executable - we want the case to be correct.
set pnormglob [file normalize $p] set pnormglob [file normalize $p]
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
#TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem. #TCL's glob on windows is case-insensitive, but in some cases return the result with the case as globbed for regardless of the actual case on the filesystem.
#(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug) #(This seems to occur when the pattern does *not* contain a wildcard and is probably a bug)
@ -6501,7 +6502,7 @@ namespace eval punk {
dict set d_index_executables $path_idx $executables dict set d_index_executables $path_idx $executables
foreach exe $executables { foreach exe $executables {
#todo - other case-insensitive platforms/filesystems. #todo - other case-insensitive platforms/filesystems.
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
#on case #on case
@ -6533,7 +6534,7 @@ namespace eval punk {
#However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables. #However we do need to add the path index to the path_indices for each executable that is found in this path - as this will affect which paths are shown as overshadowing which executables.
set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path set executables [dict get $d_index_executables [lindex [dict get $d_path_info $pnorm indices] 0]] ;#get executables for this path
foreach exe $executables { foreach exe $executables {
if {$::tcl_platform(platform) eq "windows"} { if {$is_windows} {
set exe_key [string tolower $exe] set exe_key [string tolower $exe]
} else { } else {
set exe_key $exe set exe_key $exe
@ -6596,7 +6597,11 @@ namespace eval punk {
# continue # continue
#} #}
set thisrow [list $pidx] set thisrow [list $pidx]
set pnorm [string tolower $p] if {$is_windows} {
set pnorm [string tolower $p]
} else {
set pnorm $p
}
if {[string length $pnorm] > 1} { if {[string length $pnorm] > 1} {
set lastchar [string index $pnorm end] set lastchar [string index $pnorm end]
if {$lastchar eq "/" || $lastchar eq "\\"} { if {$lastchar eq "/" || $lastchar eq "\\"} {
@ -6617,15 +6622,28 @@ namespace eval punk {
set display_executables [list] set display_executables [list]
foreach exe $executables { foreach exe $executables {
set matched_binglob 0 set matched_binglob 0
foreach bg $binglobs { if {$is_windows} {
#review - -nocase only on case-insensitive platforms/filesystems? foreach bg $binglobs {
#- but it is simpler to just apply it to all platforms here rather than trying to determine case-sensitivity of each path. #review - -nocase only on case-insensitive platforms/filesystems?
if {[string match -nocase $bg $exe]} { #todo - mac has case-insensitive filesystem by default.
set matched_binglob 1 if {[string match -nocase $bg $exe]} {
continue set matched_binglob 1
continue
}
}
} else {
foreach bg $binglobs {
if {[string match $bg $exe]} {
set matched_binglob 1
continue
}
} }
} }
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]
@ -6738,7 +6756,11 @@ namespace eval punk {
set executables [dict get $d_index_executables $original_path_idx] set executables [dict get $d_index_executables $original_path_idx]
lappend thisrow [llength $executables] lappend thisrow [llength $executables]
foreach exe $executables { foreach exe $executables {
set exe_key [string tolower $exe] if {$is_windows} {
set exe_key [string tolower $exe]
} else {
set exe_key $exe
}
if {[dict exists $d_bin_info $exe_key]} { if {[dict exists $d_bin_info $exe_key]} {
set bindata [dict get $d_bin_info $exe_key] set bindata [dict get $d_bin_info $exe_key]
set path_indices [dict get $bindata path_indices] set path_indices [dict get $bindata path_indices]

2
src/vfs/_vfscommon.vfs/modules/punk/console-0.1.1.tm
Unescape View File

@ -3634,7 +3634,7 @@ namespace eval punk::console::system {
catch { catch {
chan configure stdin -inputmode raw chan configure stdin -inputmode raw
} }
puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]" #puts "enableRaw_stty previous_stty_state_$channel: [set previous_stty_state_$channel]"
return [dict create previous [set previous_stty_state_$channel]] return [dict create previous [set previous_stty_state_$channel]]
} }
proc disableRaw_stty {{channel stdin}} { proc disableRaw_stty {{channel stdin}} {

16
src/vfs/_vfscommon.vfs/modules/textblock-0.1.3.tm
Unescape View File

@ -5751,8 +5751,13 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
see also textblock::join_basic_raw - a thin wrapper around split and join for the common case of joining blocks without any options, see also textblock::join_basic_raw - a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks
and is intended to avoid the overhead of argument parsing. without any options, and is intended to avoid the minor additional overhead of argument parsing.
For both, -ansireplays is always on (if ansi detected) and -ansiresets defaults to auto which means we will add resets at the start
and end of each line if we detect any ansi codes in the block, but won't add them if we don't detect any ansi codes in the block.
This is because joined blocks often have adjacent lines with no padding between them, so without resets at line extremes
- trailing ansi from one block's line can easily affect the corresponding line in the next block.
" "
-ansiresets -type any -default auto -ansiresets -type any -default auto
-- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags" -- -type none -optional 0 -help "end of options marker -- is mandatory because joined blocks may easily conflict with flags"
@ -5804,8 +5809,11 @@ tcl::namespace::eval textblock {
"Join blocks of text line by line but don't add padding on each line to enforce uniform width. "Join blocks of text line by line but don't add padding on each line to enforce uniform width.
Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner. Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner.
This version is a thin wrapper around split and join for the common case of joining blocks without any options, This version is a thin wrapper around split and join, but with ansireplays, for the common case of joining blocks without
and is intended to avoid the overhead of argument parsing. any options, and is intended to avoid the minor additional overhead of argument parsing.
The performance is dominated by the ansireplays processing when ansi is detected, and this will be the same for
textblock::join_basic, textblock::join_basic_raw and textblock::join.
" "
@values @values
blocks -type any -multiple 1 blocks -type any -multiple 1

Write Preview
Loading…
Cancel
Save