with <v4okm3$h4cs$1@dont-email.me> Janis Papanagnou wrote:
> On 16.06.2024 20:00, Eric Pozharski wrote:
>> with <v4ll54$3sd11$1@dont-email.me> Janis Papanagnou wrote:

*SKIP* [ 20 lines 3 levels deep]
>> That being said, as a result of cross-pollination, something similar
>> might be in ksh too. I can't say where to dig through
>> ksh-documentation.
>
> Well, I don't know of any in Ksh. (That's my problem.)

Is it because oh-my-bad documentation or ksh seeks minimal feature-set?

p.s. Lack of features is a feature by itself, there's that.

--
Torvalds' goal for Linux is very simple: World Domination
Stallman's goal for GNU is even simpler: Freedom

On 18.06.2024 16:54, Eric Pozharski wrote:
> with <v4okm3$h4cs$1@dont-email.me> Janis Papanagnou wrote:
>> On 16.06.2024 20:00, Eric Pozharski wrote:
>>> with <v4ll54$3sd11$1@dont-email.me> Janis Papanagnou wrote:

[ zsh's glob qualifier for numerically sorted glob expansion ]

> *SKIP* [ 20 lines 3 levels deep]
>>> That being said, as a result of cross-pollination, something similar
>>> might be in ksh too. I can't say where to dig through
>>> ksh-documentation.
>>
>> Well, I don't know of any in Ksh. (That's my problem.)
>
> Is it because oh-my-bad documentation or ksh seeks minimal feature-set?

Ksh has really a lot features. But not this ["basic" (sort of)] one.

(Well, I might as well have just missed it in the docs, but there's
also the Bolsky/Korn book where I didn't see it. And I'm using that
shell so long. And I've also got no hints yet.)

> p.s. Lack of features is a feature by itself, there's that.

Lacking features is certainly no feature of Ksh. ;-)

Janis

Geoff Clare <geoff@clare.See-My-Signature.invalid>:
> Helmut Waitzmann wrote:
>
>> If ‘p_sort’ is designed to output the sorted file names
>> separated by an ASCII NUL character rather than a newline
>> then, using the GNU version of ‘xargs’, one can feed that
>> output into ‘xargs’:
>>
>>
>> {
>> p_sort P*.HTM 3<&- |
>> xargs --null --no-run-if-empty -- sh -c \
>> 'exec 0<&3 3<&- "$@"' sh \
>> viewer
>> } 3<&0
>
> NUL as a record separator is also supported by several other
> versions of xargs, and it is in the recently released
> POSIX.1-2024 standard.
>

I'm glad to read that.  I didn't know either.

> In all of those it is specified with -0, so using -0 is more
> portable than the GNU-specific --null.
>

Yes, of course:  If ‘-0’ is in the POSIX standard, it is
preferable over ‘--null’.

> POSIX.1-2024 also has -r although I think that's not as widely
> supported in current xargs implementations as -0. It should
> become better supported over time, though, so again I would
> suggest using -r rather than --no-run-if-empty for better future
> portability.
>

I didn't know, that ‘-0’ as well as ‘-r’ are more widely
available (with the same semantics) than just in the GNU
version.  To minimize the risk of having a ‘xargs’ version, which
by accident uses the options ‘-0’ or ‘-r’ with different
semantics than GNU ‘xargs’ does, I preferred the long options (in
particular ‘--no-run-if-empty’) over the short.

On 2024-06-18, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
> On Mon, 17 Jun 2024 09:44:55 +0200, Janis Papanagnou wrote:
>
>> IOW; I'd have to learn Python completely to understand your code and get
>> the details properly.
>
> I give you a fish, you eat for a day. You learn to fish, you eat for a
> lifetime.

You fall into the Python trap, and eat shit for a lifetime.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

On 18/06/2024 at 18:04, Janis Papanagnou wrote:
> I've just tried a Unix tools based solution (with sed, sort, cut).
>
> Up to and including the line containing 'shuf' is data generation,
> the rest (starting with 'sed') extracts and sorts the data. I've
> written it for TWO numeric sort keys (see printf format specifier)
>
> for (( i=1; i<=50; i++ )) do for (( j=2; j<=120; j+=3 )) do printf
> "a%db%dc.txt\n" i j done done | shuf |
>
> sed 's/[^0-9]*\([0-9]\+\)[^0-9]*\([0-9]\+\)[^0-9]*/\1\t\2\t&/' | sort
> -t$'\t' -k1n -k2n | cut -f3-
>
> For just one numeric argument this can be simplified (shorter sed
> pattern, simpler sort -n command), and for more than two numeric
> fields it can be modified to dynamically construct the sed pattern,
> the sort option list, and the cut parameter, once at the beginning;
> that way we could have a tool for arbitrary amounts of numeric keys
> in the file name.
>
> Note: this program doesn't handle pathological filenames (newlines).
>
> Janis
>
>
If you're happy not handling pathological filenames:

for (( i=1; i<=50; i++ )); do for (( j=2; j<=120; j+=3 )); do touch
"a${i}b${j}c.txt"; done; done
to create the files.

exnums() { j="$(sed 's/[^[:digit:]]\+/ /g' <<<"$@")"; printf '%s%s\n'
"$j" "$@"; }
function replaces all non-digit sequences with a space, prints digit
sequence(s) and original input.

for i in *; do exnums "$i"; done | sort -k1n -k2n -k3n -k4n | awk
'{print $NF}'
sort doesn't seem to care how many -k you use, fields separated with space.
awk prints the last field of the input.

This "seems" to work with all manner of filenames from PNN.htm (as your
original sequence) to p323dc45g12.htm, p324dc45g12.htm, p333dc45g12.htm
Seems to work in ksh, too.

--
Chris Elvidge, England
TAR IS NOT A PLAYTHING

On 19.06.2024 14:40, Chris Elvidge wrote:
> On 18/06/2024 at 18:04, Janis Papanagnou wrote:
>> I've just tried a Unix tools based solution (with sed, sort, cut).
>> [...]
>> [...], and for more than two numeric
>> fields it can be modified to dynamically construct the sed pattern,
>> the sort option list, and the cut parameter, once at the beginning;
>> that way we could have a tool for arbitrary amounts of numeric keys in
>> the file name.
>>
>> Note: this program doesn't handle pathological filenames (newlines).
>>
>
> If you're happy not handling pathological filenames:

Well, typically I can indeed ignore them. But it's better of course
to avoid situations where processing is compromised by such names.

>
> for (( i=1; i<=50; i++ )); do for (( j=2; j<=120; j+=3 )); do touch
> "a${i}b${j}c.txt"; done; done
> to create the files.
>
> exnums() { j="$(sed 's/[^[:digit:]]\+/ /g' <<<"$@")"; printf '%s%s\n'
> "$j" "$@"; }
> function replaces all non-digit sequences with a space, prints digit
> sequence(s) and original input.
>
> for i in *; do exnums "$i"; done | sort -k1n -k2n -k3n -k4n | awk
> '{print $NF}'
> sort doesn't seem to care how many -k you use, fields separated with space.
> awk prints the last field of the input.
>
> This "seems" to work with all manner of filenames from PNN.htm (as your
> original sequence) to p323dc45g12.htm, p324dc45g12.htm, p333dc45g12.htm
> Seems to work in ksh, too.

I tried the approach I outlined above... (here just echo'ing the
created parts)...

N=${1:-1}
sed_a="[^0-9]*\([0-9]\+\)[^0-9]*"
sed_r="\1\t"
sort_a="-k1n"
for (( n=2; n<=N; n++ ))
do
sed_a+="\([0-9]\+\)[^0-9]*"
sed_r+="\\${n}\t"
sort_a+=" -k${n}n"
done
cut_a="-f$((N+1))-"

echo "# The following commands would be connected by pipes:"
echo "sed 's/${sed_a}/${sed_r}&/'"
echo "sort -t$'\t' ${sort_a}"
echo "cut ${cut_a}"

Janis

On 19/06/2024 at 14:11, Janis Papanagnou wrote:
> On 19.06.2024 14:40, Chris Elvidge wrote:
>> On 18/06/2024 at 18:04, Janis Papanagnou wrote:
>>> I've just tried a Unix tools based solution (with sed, sort, cut).
>>> [...]
>>> [...], and for more than two numeric
>>> fields it can be modified to dynamically construct the sed pattern,
>>> the sort option list, and the cut parameter, once at the beginning;
>>> that way we could have a tool for arbitrary amounts of numeric keys in
>>> the file name.
>>>
>>> Note: this program doesn't handle pathological filenames (newlines).
>>>
>>
>> If you're happy not handling pathological filenames:
>
> Well, typically I can indeed ignore them. But it's better of course
> to avoid situations where processing is compromised by such names.
>
>>
>> for (( i=1; i<=50; i++ )); do for (( j=2; j<=120; j+=3 )); do touch
>> "a${i}b${j}c.txt"; done; done
>> to create the files.
>>
>> exnums() { j="$(sed 's/[^[:digit:]]\+/ /g' <<<"$@")"; printf '%s%s\n'
>> "$j" "$@"; }
>> function replaces all non-digit sequences with a space, prints digit
>> sequence(s) and original input.
>>
>> for i in *; do exnums "$i"; done | sort -k1n -k2n -k3n -k4n | awk
>> '{print $NF}'
>> sort doesn't seem to care how many -k you use, fields separated with space.
>> awk prints the last field of the input.
>>
>> This "seems" to work with all manner of filenames from PNN.htm (as your
>> original sequence) to p323dc45g12.htm, p324dc45g12.htm, p333dc45g12.htm
>> Seems to work in ksh, too.
>
> I tried the approach I outlined above... (here just echo'ing the
> created parts)...
>
>
> N=${1:-1}
> sed_a="[^0-9]*\([0-9]\+\)[^0-9]*"
> sed_r="\1\t"
> sort_a="-k1n"
> for (( n=2; n<=N; n++ ))
> do
> sed_a+="\([0-9]\+\)[^0-9]*"
> sed_r+="\\${n}\t"
> sort_a+=" -k${n}n"
> done
> cut_a="-f$((N+1))-"
>
> echo "# The following commands would be connected by pipes:"
> echo "sed 's/${sed_a}/${sed_r}&/'"
> echo "sort -t$'\t' ${sort_a}"
> echo "cut ${cut_a}"
>
>
> Janis
>

Your way is still restricted to filenames with a known number of sets of
digits, though (AFAICS). I.e. you pass N rather than finding it.

But it takes a long time to do it my way, a call to sed for each
filename, so I tried to cut down the time taken to do this and came up with:

bash: exnums() { shopt -s extglob; j="${@//+([^[:digit:]])/ }"; printf
'%s%s\n' "$j" "$@"; }

ksh: exnums() { j="${@//+([^[:digit:]])/ }"; printf '%s%s\n' "$j" "$@"; }

ksh seems to do the extglob needed for bash natively.

removing the sed calls from exnum changes the time taken from 37 secs to
under 1 sec with 2000+ files
ksh is faster than bash, ksh 50% of the bash time taken.

Substituting a tab for the replacement space in j= and -t$'\t' in sort
would seem to allow spaces in filenames, too, as you originally had it.

--
Chris Elvidge, England
SUBSTITUTE TEACHERS ARE NOT SCABS

On Wed, 19 Jun 2024 16:06:37 +0100, Chris Elvidge <chris@x550c.mshome.net>
wrote in <v4us5u$21bu3$1@dont-email.me>:

> On 19/06/2024 at 14:11, Janis Papanagnou wrote:
>> On 19.06.2024 14:40, Chris Elvidge wrote:
>>> On 18/06/2024 at 18:04, Janis Papanagnou wrote:
>>>> I've just tried a Unix tools based solution (with sed, sort, cut).
>>>> [...]
>>>> [...], and for more than two numeric fields it can be modified to
>>>> dynamically construct the sed pattern, the sort option list, and the
>>>> cut parameter, once at the beginning; that way we could have a tool
>>>> for arbitrary amounts of numeric keys in the file name.
>>>>
>>>> Note: this program doesn't handle pathological filenames (newlines).
>>>>
>>>>
>>> If you're happy not handling pathological filenames:
>>
>> Well, typically I can indeed ignore them. But it's better of course to
>> avoid situations where processing is compromised by such names.
>>
>>
>>> for (( i=1; i<=50; i++ )); do for (( j=2; j<=120; j+=3 )); do touch
>>> "a${i}b${j}c.txt"; done; done to create the files.
>>>
>>> exnums() { j="$(sed 's/[^[:digit:]]\+/ /g' <<<"$@")"; printf '%s%s\n'
>>> "$j" "$@"; }
>>> function replaces all non-digit sequences with a space, prints digit
>>> sequence(s) and original input.
>>>
>>> for i in *; do exnums "$i"; done | sort -k1n -k2n -k3n -k4n | awk
>>> '{print $NF}'
>>> sort doesn't seem to care how many -k you use, fields separated with
>>> space.
>>> awk prints the last field of the input.
>>>
>>> This "seems" to work with all manner of filenames from PNN.htm (as
>>> your original sequence) to p323dc45g12.htm, p324dc45g12.htm,
>>> p333dc45g12.htm Seems to work in ksh, too.
>>
>> I tried the approach I outlined above... (here just echo'ing the
>> created parts)...
>>
>>
>> N=${1:-1}
>> sed_a="[^0-9]*\([0-9]\+\)[^0-9]*"
>> sed_r="\1\t"
>> sort_a="-k1n"
>> for (( n=2; n<=N; n++ ))
>> do
>> sed_a+="\([0-9]\+\)[^0-9]*"
>> sed_r+="\\${n}\t" sort_a+=" -k${n}n"
>> done cut_a="-f$((N+1))-"
>>
>> echo "# The following commands would be connected by pipes:"
>> echo "sed 's/${sed_a}/${sed_r}&/'"
>> echo "sort -t$'\t' ${sort_a}"
>> echo "cut ${cut_a}"
>>
>>
>> Janis
>>
>>
> Your way is still restricted to filenames with a known number of sets of
> digits, though (AFAICS). I.e. you pass N rather than finding it.
>
> But it takes a long time to do it my way, a call to sed for each
> filename, so I tried to cut down the time taken to do this and came up
> with:
>
> bash: exnums() { shopt -s extglob; j="${@//+([^[:digit:]])/ }"; printf
> '%s%s\n' "$j" "$@"; }
>
> ksh: exnums() { j="${@//+([^[:digit:]])/ }"; printf '%s%s\n' "$j" "$@";
> }
>
> ksh seems to do the extglob needed for bash natively.
>
> removing the sed calls from exnum changes the time taken from 37 secs to
> under 1 sec with 2000+ files ksh is faster than bash, ksh 50% of the
> bash time taken.
>
> Substituting a tab for the replacement space in j= and -t$'\t' in sort
> would seem to allow spaces in filenames, too, as you originally had it.

I finally remembered which tool has "versionsort(3)" -- it's ls:

$ ls -1
test10.txt
test1.txt
test2.txt

$ ls -v -1
test1.txt
test2.txt
test10.txt

Does that help?

--
-v

On 19.06.2024 17:06, Chris Elvidge wrote:
> On 19/06/2024 at 14:11, Janis Papanagnou wrote:
>>> [...]
>>
>> I tried the approach I outlined above... (here just echo'ing the
>> created parts)...
>>
>>
>> N=${1:-1}
>> sed_a="[^0-9]*\([0-9]\+\)[^0-9]*"
>> sed_r="\1\t"
>> sort_a="-k1n"
>> for (( n=2; n<=N; n++ ))
>> do
>> sed_a+="\([0-9]\+\)[^0-9]*"
>> sed_r+="\\${n}\t"
>> sort_a+=" -k${n}n"
>> done
>> cut_a="-f$((N+1))-"
>>
>> echo "# The following commands would be connected by pipes:"
>> echo "sed 's/${sed_a}/${sed_r}&/'"
>> echo "sort -t$'\t' ${sort_a}"
>> echo "cut ${cut_a}"
>>
>
> Your way is still restricted to filenames with a known number of sets of
> digits, though (AFAICS). I.e. you pass N rather than finding it.

Yes. Above is just a codified version of the method I described
(thus also the echo's). Whether it's provided as parameter N or
obtained, say, from one of the files is left unanswered. Myself
I'd prefer some solution where even file sets with mixed amounts
of numerical parts may be used; thus being able to handle lists
that are named like chapters, like 1, 1.1, 1.2, ..., 5.3.3

Slowly and continuously approaching the goal... :-)

Janis

> [...]

On 20.06.2024 01:45, vallor wrote:
>> [...]
>
> I finally remembered which tool has "versionsort(3)" -- it's ls:
>
> $ ls -1
> test10.txt
> test1.txt
> test2.txt
>
> $ ls -v -1
> test1.txt
> test2.txt
> test10.txt
>
> Does that help?

Sure, thanks. - Just remember that it's a non-standard option. But
for my GNU environment it's certainly a usable part of the solution.
It seems to also handle multiple numeric components as desired (as
versions usually have)

$ ls | shuf | xargs ls -v
1 1.2 1.11 2.1 2.10 10.1 10.10 11.1
1.1 1.10 2 2.2 2.11 10.2 10.11 11.2

Janis

On 20.06.2024 01:45, vallor wrote:
>
> I finally remembered which tool has "versionsort(3)" -- [...]

It's a pity that this function is a GNU extension, otherwise
it could be used to implement the desired function in shells
(ksh, bash) as an additional globbing option (like the zsh
glob qualifier) or a new 'set' option to control the sorting.

Janis

On Thu, 20 Jun 2024 06:58:11 +0200, Janis Papanagnou
<janis_papanagnou+ng@hotmail.com> wrote in <v50ct5$2e2lp$1@dont-email.me>:

> On 20.06.2024 01:45, vallor wrote:
>>
>> I finally remembered which tool has "versionsort(3)" -- [...]
>
> It's a pity that this function is a GNU extension, otherwise it could be
> used to implement the desired function in shells (ksh, bash) as an
> additional globbing option (like the zsh glob qualifier) or a new 'set'
> option to control the sorting.
>
> Janis

I just posted a python program to comp.lang.python that sorts parameters
using strverscmp(3). It also shell-escapes the (common) IFS characters.

--
-v

On Thu, 20 Jun 2024 22:16:42 -0000 (UTC), vallor wrote:

> I just posted a python program to comp.lang.python that sorts parameters
> using strverscmp(3).

I already posted a snippet here which sorts strings containing any number
of decimal-numerical segments.

On Fri, 21 Jun 2024 03:37:51 -0000 (UTC), Lawrence D'Oliveiro
<ldo@nz.invalid> wrote in <v52sif$3019v$1@dont-email.me>:

> On Thu, 20 Jun 2024 22:16:42 -0000 (UTC), vallor wrote:
>
>> I just posted a python program to comp.lang.python that sorts
>> parameters using strverscmp(3).
>
> I already posted a snippet here which sorts strings containing any
> number of decimal-numerical segments.

While I can't speak for others, something about the way you
went about that rubbed me the wrong way.

More on-topic, I did post the code in comp.lang.python with a request
for comments. Sometimes I feel like Manfred Mann's "The Demolition Man",
where "I kill conversation as I walk into the room." It is no exception
there, even though it would seem to be a good example of using a C binding
with python's sort function. (Having very little experience with python
programming, I couldn't really say with confidence -- but nobody has
complained so far.)

I wrote it to learn something about python, and to be a (q&d) shell
utility that someone might find useful, possibly Janis. Since
this is the shell newsgroup, and not the python programming
newsgroup, I think discussing the finer points of python
programming really don't belong here. YMMV.

I'm also put-off by "snip-and-snark" Usenet. I know a few people who
do that to tick-off the person they're conversing with. I'm guilty
of doing that from time to time, but I hope it's only when
the situation warrants it. If my opinion matters: it's a bad habit to
do so by default.

--
-v

On Fri, 21 Jun 2024 04:20:47 -0000 (UTC), vallor wrote:

> While I can't speak for others, something about the way you went about
> that rubbed me the wrong way.

I solved the specific problem that seems to be the stumbling block, and
left the rest as an exercise for the reader.

That wasn’t up to your particular high standards? You know what you can
do.

In article <v533pd$318so$1@dont-email.me>,
Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>On Fri, 21 Jun 2024 04:20:47 -0000 (UTC), vallor wrote:
>
>> While I can't speak for others, something about the way you went about
>> that rubbed me the wrong way.
>
>I solved the specific problem that seems to be the stumbling block, and
>left the rest as an exercise for the reader.
>
>That wasnt up to your particular high standards? You know what you can
>do.

Somebody's fee-fees are getting more than a little butt-hurt...

Sad.

--
Those on the right constantly remind us that America is not a
democracy; now they claim that Obama is a threat to democracy.

On 20/06/24 00:45, vallor wrote:
> On Wed, 19 Jun 2024 16:06:37 +0100, Chris Elvidge <chris@x550c.mshome.net>
> wrote in <v4us5u$21bu3$1@dont-email.me>:
>
>> On 19/06/2024 at 14:11, Janis Papanagnou wrote:
>>> On 19.06.2024 14:40, Chris Elvidge wrote:
>>>> On 18/06/2024 at 18:04, Janis Papanagnou wrote:
>>>>> I've just tried a Unix tools based solution (with sed, sort, cut).
>>>>> [...]
>>>>> [...], and for more than two numeric fields it can be modified to
>>>>> dynamically construct the sed pattern, the sort option list, and the
>>>>> cut parameter, once at the beginning; that way we could have a tool
>>>>> for arbitrary amounts of numeric keys in the file name.
>>>>>
>>>>> Note: this program doesn't handle pathological filenames (newlines).
>>>>>
>>>>>
>>>> If you're happy not handling pathological filenames:
>>>
>>> Well, typically I can indeed ignore them. But it's better of course to
>>> avoid situations where processing is compromised by such names.
>>>
>>>
>>>> for (( i=1; i<=50; i++ )); do for (( j=2; j<=120; j+=3 )); do touch
>>>> "a${i}b${j}c.txt"; done; done to create the files.
>>>>
>>>> exnums() { j="$(sed 's/[^[:digit:]]\+/ /g' <<<"$@")"; printf '%s%s\n'
>>>> "$j" "$@"; }
>>>> function replaces all non-digit sequences with a space, prints digit
>>>> sequence(s) and original input.
>>>>
>>>> for i in *; do exnums "$i"; done | sort -k1n -k2n -k3n -k4n | awk
>>>> '{print $NF}'
>>>> sort doesn't seem to care how many -k you use, fields separated with
>>>> space.
>>>> awk prints the last field of the input.
>>>>
>>>> This "seems" to work with all manner of filenames from PNN.htm (as
>>>> your original sequence) to p323dc45g12.htm, p324dc45g12.htm,
>>>> p333dc45g12.htm Seems to work in ksh, too.
>>>
>>> I tried the approach I outlined above... (here just echo'ing the
>>> created parts)...
>>>
>>>
>>> N=${1:-1}
>>> sed_a="[^0-9]*\([0-9]\+\)[^0-9]*"
>>> sed_r="\1\t"
>>> sort_a="-k1n"
>>> for (( n=2; n<=N; n++ ))
>>> do
>>> sed_a+="\([0-9]\+\)[^0-9]*"
>>> sed_r+="\\${n}\t" sort_a+=" -k${n}n"
>>> done cut_a="-f$((N+1))-"
>>>
>>> echo "# The following commands would be connected by pipes:"
>>> echo "sed 's/${sed_a}/${sed_r}&/'"
>>> echo "sort -t$'\t' ${sort_a}"
>>> echo "cut ${cut_a}"
>>>
>>>
>>> Janis
>>>
>>>
>> Your way is still restricted to filenames with a known number of sets of
>> digits, though (AFAICS). I.e. you pass N rather than finding it.
>>
>> But it takes a long time to do it my way, a call to sed for each
>> filename, so I tried to cut down the time taken to do this and came up
>> with:
>>
>> bash: exnums() { shopt -s extglob; j="${@//+([^[:digit:]])/ }"; printf
>> '%s%s\n' "$j" "$@"; }
>>
>> ksh: exnums() { j="${@//+([^[:digit:]])/ }"; printf '%s%s\n' "$j" "$@";
>> }
>>
>> ksh seems to do the extglob needed for bash natively.
>>
>> removing the sed calls from exnum changes the time taken from 37 secs to
>> under 1 sec with 2000+ files ksh is faster than bash, ksh 50% of the
>> bash time taken.
>>
>> Substituting a tab for the replacement space in j= and -t$'\t' in sort
>> would seem to allow spaces in filenames, too, as you originally had it.
>
> I finally remembered which tool has "versionsort(3)" -- it's ls:
>
> $ ls -1
> test10.txt
> test1.txt
> test2.txt
>
> $ ls -v -1
> test1.txt
> test2.txt
> test10.txt
>
> Does that help?
>

I didn't realise it could work like that. Thanks.

--
Chris Elvidge
England

In article <7cbgkkx149.ln2@slack15-a.local.uk>,
....
>> I finally remembered which tool has "versionsort(3)" -- it's ls:
>>
>> $ ls -1
>> test10.txt
>> test1.txt
>> test2.txt
>>
>> $ ls -v -1
>> test1.txt
>> test2.txt
>> test10.txt
>>
>> Does that help?
>>
>
>I didn't realise it could work like that. Thanks.

To OP: Does "ls -v" meet your criteria?

--
Faced with the choice between changing one's mind and proving that there is
no need to do so, almost everyone gets busy on the proof.

- John Kenneth Galbraith -

On 24.06.2024 15:22, Kenny McCormack wrote:
> In article <7cbgkkx149.ln2@slack15-a.local.uk>,
> ...
>>> I finally remembered which tool has "versionsort(3)" -- it's ls:
>>>
>>> $ ls -1
>>> test10.txt
>>> test1.txt
>>> test2.txt
>>>
>>> $ ls -v -1
>>> test1.txt
>>> test2.txt
>>> test10.txt
>>>
>>> Does that help?
>>>
>>
>> I didn't realise it could work like that. Thanks.
>
> To OP: Does "ls -v" meet your criteria?

Yes, at least partly. (Why are you asking?)

It meets it in the way that it's ready available and usable
as external command. It does not solve the shell internal
additional globbing feature (like in Zsh) that would be
nice and preferable.

In the quoted form as 'ls -vQ' some pathological filenames
are (seemingly) handled, but there's some hassle with the
quotes in the subsequent processing steps to expect (or so
I think). That's why an integrated form supported by shell
would IMO be an advantage; so that we could simply write

set -o numsortglob # <-- hypothetical shell feature
for f in version*.gz
do ...
done

At least the output from code like

for f in $(ls -vQ) ; do printf "'%s'\n" "$f" ; done

or

ls -vQ | while IFS= read -r f ; do printf "'%s'\n" "$f" ; done

indicates that there's still something to do, and without
the 'ls -Q' quotes the (pathological) newlines are an issue
(at least).

I think it's a typical problem that would best be solved
by a shell built-in feature. (External tools may take you
part of the road and probably with additional effort for
common subsets of the task but probably not bullet-proof.)

Janis

On 20/06/2024 at 05:34, Janis Papanagnou wrote:
> On 19.06.2024 17:06, Chris Elvidge wrote:
>> On 19/06/2024 at 14:11, Janis Papanagnou wrote:
>>>> [...]
>>>
>>> I tried the approach I outlined above... (here just echo'ing the
>>> created parts)...
>>>
>>>
>>> N=${1:-1}
>>> sed_a="[^0-9]*\([0-9]\+\)[^0-9]*"
>>> sed_r="\1\t"
>>> sort_a="-k1n"
>>> for (( n=2; n<=N; n++ ))
>>> do
>>> sed_a+="\([0-9]\+\)[^0-9]*"
>>> sed_r+="\\${n}\t"
>>> sort_a+=" -k${n}n"
>>> done
>>> cut_a="-f$((N+1))-"
>>>
>>> echo "# The following commands would be connected by pipes:"
>>> echo "sed 's/${sed_a}/${sed_r}&/'"
>>> echo "sort -t$'\t' ${sort_a}"
>>> echo "cut ${cut_a}"
>>>
>>
>> Your way is still restricted to filenames with a known number of sets of
>> digits, though (AFAICS). I.e. you pass N rather than finding it.
>
> Yes. Above is just a codified version of the method I described
> (thus also the echo's). Whether it's provided as parameter N or
> obtained, say, from one of the files is left unanswered. Myself
> I'd prefer some solution where even file sets with mixed amounts
> of numerical parts may be used; thus being able to handle lists
> that are named like chapters, like 1, 1.1, 1.2, ..., 5.3.3
>
> Slowly and continuously approaching the goal... :-)
>
> Janis
>
>> [...]
>

Originally you said:
(Ideally I'd also like to handle names with two numbers "A35P56.txt"
and irregular string components (lowercase, say, "page310ch1.txt"),
but that's just a nice-to-have. - I might make use of 'sort'?)

Does 'sort -V' help?
Seems to work with both spaces and newlines.

--
Chris Elvidge, England
NO ONE CARES WHAT MY DEFINITION OF "IS" IS

On 24.06.2024 16:22, Chris Elvidge wrote:
>>[...]
>
> Originally you said:
> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
> and irregular string components (lowercase, say, "page310ch1.txt"),
> but that's just a nice-to-have. - I might make use of 'sort'?)
>
> Does 'sort -V' help?
> Seems to work with both spaces and newlines.

Yes, that would help like 'ls -v' does (presuming it behaves similar;
I haven't extensively tried 'sort -V' yet). (But using 'ls | sort -V'
is not that terse like 'ls -v'.) The problem with both external tools
is (as outlined upthread) the post-processing of the tool-generated
list of data in shell context. So both tools take some burden from
me (the sorting aspect is simply covered by an option), but doesn't
help me how I can safely post-process the identified items. (A shell
built-in could natively better, i.e. simpler and more consistently,
address that.)

Janis