Camel hump string split

Question

Given System names of 2 or more characters:

systemNames = Names["System`*"] // Select[StringLength[#] > 1 &] ;

Is there a more compact way to split at upper case letters that avoids the Partition and subsequent StringJoin?

EDIT: match to digits as well as upper case, but still w/ limitations outlined below:

systemNames // 
  Map[StringSplit[#, 
      x : c_ /; (UpperCaseQ[c] || DigitQ[c]) :> x] & /* (Partition[#, 2] & )] // 
 Map[Map[StringJoin]] 

Also, what's the easiest way to also split at $ and also the final upper case char, eg N? I coudn't find an easy way with Alternatives and longer ___.

Answer 1

You can do all of it directly with StringCases!

StringCases[systemNames, hump : (CharacterRange["A", "Z"] | DigitCharacter) | "$" ~~ restOfCamel : CharacterRange["a", "z"] ...]

(*
{{A,A,S,Triangle},{Abelian,Group},{Abort},{Abort,Kernels},{Abort,Protect},
{Above},{Abs}, ...5182... ,{$,User,Base,Directory},
{$,User,Documents,Directory},{$,User,Name},{$,Version},{$,Version,Number},
{$,Wolfram,I,D},{$,Wolfram,U,U,I,D}}
*)

And, out of pure envy, a version that wrongly groups abbreviations as suggested by @WReach!

StringCases[systemNames, hump : CharacterRange["A", "Z"] .. | "$" ~~ restOfCamel : CharacterRange["a", "z"] ...]

(*
{{AASTriangle},{Abelian,Group},{Abort},{Abort,Kernels},{Abort,Protect},{Above},
{Abs},{Absolute}, ...5185... ,{$,User,Base,Directory},
{$,User,Documents,Directory},{$,User,Name},{$,Version},{$,Version,Number},
{$,Wolfram,ID},{$,Wolfram,UUID}}
*)

Just 2 dots of difference! Finally something that was easier to do with ordinary patterns instead of regexes! Noooot.

Finally

A version with ordinary patterns that does the marvels that @WReach`s look-ahead regexes can do. Two separate pattern "levels" must be used, though.

StringCases[systemNames, hump : (CharacterRange["A", "Z"] | DigitCharacter) | "$" ~~ restOfCamel : CharacterRange["a", "z"] ...]
Replace[%, {pre___, Longest[d1__?UpperCaseQ], post___} :> {pre, StringJoin@d1, post}, {1}]

(*
{{"AAS", "Triangle"}, {"Abelian", "Group"}, {"Abort"}, {"Abort", "Kernels"}, {"Abort", "Protect"},
{"Above"}, {"Abs"}, {"Absolute"}, ...5184... , {"$", "User", "Base", "Directory"},
{"$", "User", "Documents","Directory"}, {"$", "User", "Name"}, {"$", "Version"}, {"$", "Version", "Number"},
{"$", "Wolfram", "ID"}, {"$", "Wolfram", "UUID"}}
*)

And a quick fix for the {Te,X} issue

Replace[%, {pre___, "Te", "X", post___} :> {pre, "TeX", post}, {1}]

Answer 2

Here is a method using StringSplit and RegularExpression:

StringSplit[systemNames, RegularExpression["(?=[$[:upper:]])"]]

(*
   {{A,A,S,Triangle},{Abelian,Group},{Abort},{Abort,Kernels},{Abort,Protect},
    {Above},{Abs},<<5192>>,{$,User,Documents,Directory},{$,User,Name},{$,Version},
    {$,Version,Number},{$,Wolfram,I,D},{$,Wolfram,U,U,I,D}}
*)

It works by splitting each string wherever it finds a zero-length substring which is followed by a dollar sign or an upper case character. (?=...) is the zero-length look-ahead syntax. [$[:upper:]] matches any character in the set comprised of the literal dollar sign along with all members of the upper case character class.

It might be interesting to keep groups of otherwise loose upper case letters together and treat them as abbreviations. If so, then:

StringSplit[
  systemNames
, RegularExpression[
    "(?=\\$)|(?<![[:upper:]])(?=[[:upper:]])|(?=[[:upper:]][^[:upper:]])"
  ]
]

(*
   {{AAS,Triangle},{Abelian,Group},{Abort},{Abort,Kernels},{Abort,Protect},
    {Above},<<5191>>,{$,User,Name},{$,Version},{$,Version,Number},
        {$,Wolfram,ID},{$,Wolfram,UUID}}
*)

Note how "AAS" in the first entry and "UUID" in the last are kept together as abbreviations. This pattern works by matching a dollar sign, or an upper case letter that is not preceded by another upper case letter, or an upper case letter followed by a non-uppercase letter.

Edit: Including Digits as "Hump" Characters

A comment requests that digits be treated as "hump" characters. This is accomplished by changing each occurrence of the regular expression pattern [[:upper:]] to [\\d[:upper:]]. \\d matches any digit character.

namesWithDigits = Select[systemNames, !StringFreeQ[#, DigitCharacter]&];

StringSplit[namesWithDigits, RegularExpression[#]]& @
    "(?=\\$)|(?<![\\d[:upper:]])(?=[\\d[:upper:]])|(?=[\\d[:upper:]][^\\d[:upper:]])"

(*
  {{Appell,F1},{Arrow,3D,Box},{Bar,Chart,3D},{Bezier,Curve,3D,Box},<<85>>,
   {Text,3D,Box},{Text,3D,Box,Options},{V2,Get},{Vector,Plot,3D}}
*)

Answer 3

Using insights from WReach and Aisamu here's a version with good properties on system names:

humpCharacters = 
  Flatten@{CharacterRange["A", "Z"], CharacterRange["0", "9"]};

.

StringSplit[systemNames, 
  c : humpCharacters ~~ 
    rest : Except[Append[humpCharacters, "$"]] .. :> c <> rest] // 
  Map[Select[# != "" &]]

From visual inspection of output (~5000 names) only the following issues are apparant:

(* "TeX" --> {"Te", "X", "Form"}, {"Te", "X", "Save"} 
   "$HTML", "$HTTP" --> {"$HTML", "Export", "Rules"}, {"$HTTP", "Cookies"}  *)