Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
3
Task/Camel-case-and-snake-case/00-META.yaml
Normal file
3
Task/Camel-case-and-snake-case/00-META.yaml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Camel_case_and_snake_case
|
||||
note: Camel Case and Snake Case
|
||||
21
Task/Camel-case-and-snake-case/00-TASK.txt
Normal file
21
Task/Camel-case-and-snake-case/00-TASK.txt
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
Two common conventions for naming of computer program variables are '''Snake Case''' and
|
||||
'''Camel Case'''.
|
||||
|
||||
'''Snake case''' variables are generally all lower case, with an underscore between words in the variable, as in '''snake_case_variable''''. '''Camel case''' variables are generally lower case first (except in some Pascal conventions or with class names in many other languages), with captalization of the initial letter of the words within the variable, as in ''''camelCaseVariable''''.
|
||||
|
||||
Leading underscores are not used in such variables except as part of a different naming convention, usually for special internal or system variables. White space is not permitted as part of camel case or snake case variable names.
|
||||
|
||||
;Task:
|
||||
|
||||
:* Write two functions, one to change snake case to camel case and one to change camel case to snake case. If possible, generalize the function enough to apply to strings containing spaces between words or a `-` dash between words, assuming that in those cases a space or hyphen is a also a separator character, like `_`, for the purpose of creating a new variable name. Leading or trailing whitespace may be ignored.
|
||||
|
||||
:*Show the results on changing to both snake case and camel case for each of the following strings:
|
||||
|
||||
<syntaxhighlight lang="java">
|
||||
"snakeCase", "snake_case", "variable_10_case", "variable10Case", "ɛrgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "
|
||||
</syntaxhighlight>
|
||||
|
||||
;Related tasks:
|
||||
|
||||
* [[Naming_conventions]]
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
F snakeToCamelCase(nam, sep = ‘[_]+’, lcmiddle = 0B)
|
||||
‘ convert snake '_' separator case to camel case ’
|
||||
I nam == ‘’
|
||||
R nam
|
||||
V words = nam.trim(‘ ’).split(re:(sep))
|
||||
I lcmiddle
|
||||
words = words.map(w -> w.lowercase())
|
||||
words = [words[0]] [+] words[1..].filter(w -> w.len > 0).map(w -> w[0].uppercase()‘’w[1..])
|
||||
R words.join(‘’)
|
||||
|
||||
[(String, (String -> String))] funcs
|
||||
funcs [+]= (‘snakeToCamelCase’, nam -> snakeToCamelCase(nam))
|
||||
funcs [+]= (‘spaceToCamelCase’, nam -> snakeToCamelCase(nam, sep' ‘\s+’))
|
||||
funcs [+]= (‘kebabToCamelCase’, nam -> snakeToCamelCase(nam, sep' ‘[\-]+’))
|
||||
funcs [+]= (‘periodToCamelCase’, nam -> snakeToCamelCase(nam, sep' ‘[\.]+’))
|
||||
funcs [+]= (‘allsepToCamelCase’, nam -> snakeToCamelCase(nam, sep' ‘[ \-_\.]+’))
|
||||
funcs [+]= (‘lowermiddle_allsepToCamelCase’, nam -> snakeToCamelCase(nam, sep' ‘[ \-_\.]+’, lcmiddle' 1B))
|
||||
|
||||
F camel_to_snake_case(=nam, allsep = ‘[_]+’, sep = ‘_’, lcmiddle = 1B)
|
||||
‘ convert camel case to snake case (separate with '_') ’
|
||||
nam = nam.trim((‘ ’, "\t", "\r", "\n")).replace(re:‘([A-Z]+)’, sep‘$1’)
|
||||
V sep1 = I sep == ‘.’ {‘\’sep} E sep
|
||||
I lcmiddle
|
||||
nam = (nam.split(sep1).filter(w -> w.len > 0).map(w -> w.lowercase())).join(sep)
|
||||
E
|
||||
nam = (nam.split(sep1).filter(w -> w.len > 0).map(w -> w[0].lowercase()‘’w[1..])).join(sep)
|
||||
R nam.replace(re:(allsep), sep)
|
||||
|
||||
funcs [+]= (‘camel_to_snake_case’, nam -> camel_to_snake_case(nam))
|
||||
funcs [+]= (‘preserve_midcaps_camel_to_snake_case’, nam -> camel_to_snake_case(nam, lcmiddle' 0B))
|
||||
funcs [+]= (‘allsep_to_snake_case’, nam -> camel_to_snake_case(nam, allsep' ‘[ \-\._]+’))
|
||||
funcs [+]= (‘allsep_to_kebab_case’, nam -> camel_to_snake_case(nam, allsep' ‘[ \-\._]+’, sep' ‘-’))
|
||||
funcs [+]= (‘allsep_to_space_case’, nam -> camel_to_snake_case(nam, allsep' ‘[ \-\._]+’, sep' ‘ ’))
|
||||
funcs [+]= (‘allsep_to_period_case’, nam -> camel_to_snake_case(nam, allsep' ‘[ \-\._]+’, sep' ‘.’))
|
||||
funcs [+]= (‘allsep_to_slash_case’, nam -> camel_to_snake_case(nam, allsep' ‘[ \-\._]+’, sep' ‘/’))
|
||||
|
||||
L(f_name, f) funcs
|
||||
print(‘Testing function ’f_name‘:’)
|
||||
L(teststring) [
|
||||
‘snakeCase’,
|
||||
‘snake_case’,
|
||||
‘snake-case’,
|
||||
‘snake case’,
|
||||
‘snake CASE’,
|
||||
‘snake.case’,
|
||||
‘variable_10_case’,
|
||||
‘variable10Case’,
|
||||
‘ergo rE tHis’,
|
||||
‘hurry-up-joe!’,
|
||||
‘c://my-docs/happy_Flag-Day/12.doc’,
|
||||
‘ spaces ’]
|
||||
print(teststring.rjust(36)‘ => ’f(teststring))
|
||||
print()
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
BEGIN # convert camel case to and from snake case #
|
||||
# returns c converted to uppercase if it is lowercase, c otherwise #
|
||||
OP TOUPPER = ( CHAR c )STRING:
|
||||
IF c >= "a" AND c <= "z" THEN REPR( ( ABS c - ABS "a" ) + ABS "A" ) ELSE c FI;
|
||||
# returns c converted to lowercase if it is uppercase, c otherwise #
|
||||
OP TOLOWER = ( CHAR c )STRING:
|
||||
IF c >= "A" AND c <= "Z" THEN REPR( ( ABS c - ABS "A" ) + ABS "a" ) ELSE c FI;
|
||||
# returns the camel case identifier c in snake case #
|
||||
OP CAMELTOSNAKE = ( STRING c )STRING: c CAMELTOBREAK "_";
|
||||
# returns the camel case identifier c in kebab case #
|
||||
OP CAMELTOKEBAB = ( STRING c )STRING: c CAMELTOBREAK "-";
|
||||
# returns TRUE if c is a "break" character ( " ", "-" or "_" ), FALSE otherwise #
|
||||
OP ISBREAK = ( CHAR c )BOOL: c = " " OR c = "-" OR c = "_";
|
||||
# returns the indentifier id (which is assumed to be in Camel case) #
|
||||
# converted to snake or kebab case depending on break char #
|
||||
PRIO CAMELTOBREAK = 9; # CAMELTOBREAK is dyadic so need a priority #
|
||||
OP CAMELTOBREAK = ( STRING id, CHAR break char )STRING:
|
||||
BEGIN
|
||||
STRING result := "";
|
||||
STRING orig = TRIM id; # remove leading and trailing spaces #
|
||||
BOOL first := TRUE;
|
||||
INT c pos := LWB orig;
|
||||
WHILE c pos <= UPB orig DO
|
||||
CHAR c = orig[ c pos ];
|
||||
IF c >= "A" AND c <= "Z" THEN
|
||||
# have an uppercase letter #
|
||||
IF NOT first THEN result +:= break char FI;
|
||||
result +:= TOLOWER c
|
||||
ELIF ISBREAK c THEN
|
||||
# replace one or more spaces and break characters by a single break #
|
||||
BOOL have break := TRUE;
|
||||
WHILE c pos <= UPB orig AND have break DO
|
||||
IF have break := ISBREAK orig[ c pos ] THEN c pos +:= 1 FI
|
||||
OD;
|
||||
IF c pos <= UPB orig THEN
|
||||
# the identifier didn't end wih a break #
|
||||
result +:= break char + TOLOWER orig[ c pos ]
|
||||
FI
|
||||
ELSE
|
||||
# lowercase or punctuation #
|
||||
result +:= c
|
||||
FI;
|
||||
first := FALSE;
|
||||
c pos +:= 1
|
||||
OD;
|
||||
result
|
||||
END # CAMELTOBREAK # ;
|
||||
# returns the identifier id ( which is assumed to be in snake/kebab/space case ) #
|
||||
# converted to Camel case #
|
||||
OP TOCAMEL = ( STRING id )STRING:
|
||||
BEGIN
|
||||
STRING result := "";
|
||||
STRING orig = TRIM id; # remove leading and trailing spaces #
|
||||
INT c pos := LWB orig;
|
||||
WHILE c pos <= UPB orig DO
|
||||
CHAR c = orig[ c pos ];
|
||||
IF c >= "A" AND c <= "Z" THEN
|
||||
# uppercase letter - leave as is #
|
||||
result +:= c
|
||||
ELIF NOT ISBREAK c THEN
|
||||
# not a break - convert to lower case if necessary and move to the next #
|
||||
result +:= TOLOWER c;
|
||||
ELSE
|
||||
# have a separator - skip all subsequent separators and upcase the follower #
|
||||
BOOL have break := TRUE;
|
||||
WHILE c pos <= UPB orig AND have break DO
|
||||
IF have break := ISBREAK orig[ c pos ] THEN c pos +:= 1 FI
|
||||
OD;
|
||||
IF c pos <= UPB orig THEN
|
||||
# the identifier didn't end with a break character #
|
||||
result +:= TOUPPER orig[ c pos ]
|
||||
FI
|
||||
FI;
|
||||
c pos +:= 1
|
||||
OD;
|
||||
result
|
||||
END # TOCAMEL # ;
|
||||
# returns s left-padded to len characters or s if s is already that long #
|
||||
PRIO PAD = 9;
|
||||
OP PAD = ( INT len, STRING s )STRING:
|
||||
IF INT s len = ( UPB s - LWB s ) + 1;
|
||||
s len >= len
|
||||
THEN s
|
||||
ELSE
|
||||
STRING result := s;
|
||||
FOR i FROM s len + 1 TO len DO " " +=: result OD;
|
||||
result
|
||||
FI # PAD # ;
|
||||
# returns s with leading and trailing spaces removed #
|
||||
OP TRIM = ( STRING s )STRING:
|
||||
BEGIN
|
||||
INT left := LWB s;
|
||||
INT right := UPB s;
|
||||
WHILE IF left > right THEN FALSE ELSE s[ left ] = " " FI DO left +:= 1 OD;
|
||||
WHILE IF right < left THEN FALSE ELSE s[ right ] = " " FI DO right -:= 1 OD;
|
||||
s[ left : right ]
|
||||
END # TRIM # ;
|
||||
# task test cases #
|
||||
[]STRING identifier = ( "snakeCase", "snake_case", "variable_10_case", "variable10Case", "ɛrgo rE tHis"
|
||||
, "hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "
|
||||
);
|
||||
print( ( "to snake case:", newline ) );
|
||||
FOR i FROM LWB identifier TO UPB identifier DO
|
||||
print( ( 40 PAD identifier[ i ], " -> ", CAMELTOSNAKE identifier[ i ], newline ) )
|
||||
OD;
|
||||
print( ( "to Camel case:", newline ) );
|
||||
FOR i FROM LWB identifier TO UPB identifier DO
|
||||
print( ( 40 PAD identifier[ i ], " -> ", TOCAMEL identifier[ i ], newline ) )
|
||||
OD;
|
||||
print( ( "to kebab case:", newline ) );
|
||||
FOR i FROM LWB identifier TO UPB identifier DO
|
||||
print( ( 40 PAD identifier[ i ], " -> ", CAMELTOKEBAB identifier[ i ], newline ) )
|
||||
OD
|
||||
END
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
camelToSnake: function [str][
|
||||
i: new 0
|
||||
result: new ""
|
||||
while [i < size str][
|
||||
ch: str\[i]
|
||||
if? upper? ch [
|
||||
'result ++ `_` ++ lower str\[i]
|
||||
]
|
||||
else [
|
||||
'result ++ str\[i]
|
||||
]
|
||||
|
||||
inc 'i
|
||||
]
|
||||
return result
|
||||
]
|
||||
|
||||
snakeToCamel: function [str][
|
||||
i: new 0
|
||||
result: new ""
|
||||
while [i < size str][
|
||||
ch: str\[i]
|
||||
if? and? [ch=`_`][(i+1) < size str] [
|
||||
'result ++ upper str\[i+1]
|
||||
inc 'i
|
||||
]
|
||||
else [
|
||||
'result ++ str\[i]
|
||||
]
|
||||
|
||||
inc 'i
|
||||
]
|
||||
return result
|
||||
]
|
||||
|
||||
tests: ["snakeCase", "snake_case", "variable_10_case", "variable10Case", "ɛrgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "]
|
||||
|
||||
loop tests 'test [
|
||||
print [pad test 35 "=> camel:" snakeToCamel test "snake:" camelToSnake test]
|
||||
]
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
const TestStrings: array [0..7] of string = (
|
||||
'snakeCase', 'snake_case', 'variable_10_case', 'variable10Case',
|
||||
'\u025brgo rE tHis', 'hurry-up-joe!', 'c://my-docs/happy_Flag-Day/12.doc',
|
||||
' spaces ');
|
||||
|
||||
|
||||
function MakeCamelCase(S: string): string;
|
||||
{Convert string to camel-case}
|
||||
var I: integer;
|
||||
var Toggle: boolean;
|
||||
begin
|
||||
S:=Trim(S);
|
||||
Result:='';
|
||||
for I:=1 to Length(S) do
|
||||
if Toggle then
|
||||
begin
|
||||
Result:=Result+UpperCase(S[I]);
|
||||
Toggle:=False;
|
||||
end
|
||||
else if S[I] in [' ','_','-'] then Toggle:=True
|
||||
else Result:=Result+S[I];
|
||||
end;
|
||||
|
||||
|
||||
function MakeSnakeCase(S: string): string;
|
||||
{Convert string to snake-case}
|
||||
var I: integer;
|
||||
var Toggle: boolean;
|
||||
begin
|
||||
S:=Trim(S);
|
||||
Result:='';
|
||||
for I:=1 to Length(S) do
|
||||
if S[I] in [' ','-'] then Result:=Result+'_'
|
||||
else if S[I] in ['A'..'Z'] then
|
||||
begin
|
||||
Result:=Result+'_';
|
||||
Result:=Result+LowerCase(S[I]);
|
||||
end
|
||||
else Result:=Result+S[I];
|
||||
end;
|
||||
|
||||
procedure ConvertCamelSnake(SA: array of string; Memo: TMemo);
|
||||
var I: integer;
|
||||
var S: string;
|
||||
|
||||
function FormatStrs(S1,S2: string): string;
|
||||
begin
|
||||
Result:=Format('%35s',[S1])+' '+Format('%-35s',[S2]);
|
||||
end;
|
||||
|
||||
begin
|
||||
Memo.Lines.Add('Snake Case: ');
|
||||
for I:=0 to High(SA) do
|
||||
begin
|
||||
S:=FormatStrs(SA[I],MakeSnakeCase(SA[I]));
|
||||
Memo.Lines.Add(S);
|
||||
end;
|
||||
Memo.Lines.Add('Camel Case: ');
|
||||
for I:=0 to High(SA) do
|
||||
begin
|
||||
S:=FormatStrs(SA[I],MakeCamelCase(SA[I]));
|
||||
Memo.Lines.Add(S);
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure CamelSnakeTest(Memo: TMemo);
|
||||
{Test camel/snake conversion routines}
|
||||
begin
|
||||
ConvertCamelSnake(TestStrings,Memo);
|
||||
end;
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
USING: formatting kernel math regexp sequences splitting
|
||||
splitting.extras unicode ;
|
||||
|
||||
! ignore leading/trailing whitespace
|
||||
: preserve ( str quot -- newstr )
|
||||
[ [ blank? ] split-head [ blank? ] split-tail swap ] dip
|
||||
call glue ; inline
|
||||
|
||||
: >snake ( str -- newstr )
|
||||
[
|
||||
R/ (\p{lower}\p{upper}|\d\p{alpha}|\p{alpha}\d)/
|
||||
[ 1 short cut >lower "_" glue ] re-replace-with
|
||||
R/ [\s-]/ "_" re-replace
|
||||
] preserve ;
|
||||
|
||||
: capitalize ( str -- newstr ) 1 short cut swap >upper prepend ;
|
||||
|
||||
: >camel ( str -- newstr )
|
||||
[
|
||||
"\s_-" split harvest 1 short cut
|
||||
[ capitalize ] map append "" join
|
||||
] preserve ;
|
||||
|
||||
: test ( str -- )
|
||||
dup >snake over dup >camel
|
||||
"%u >snake %u\n%u >camel %u\n" printf ;
|
||||
|
||||
{
|
||||
"snakeCase" "snake_case" "variable_10_case" "variable10Case"
|
||||
"ɛrgo rE tHis" "hurry-up-joe!"
|
||||
"c://my-docs/happy_Flag-Day/12.doc" " spaces "
|
||||
" internal space "
|
||||
} [ test ] each
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
def isUpper: explode[0] | 65 <= . and . <= 90;
|
||||
|
||||
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
|
||||
|
||||
# "White space is not permitted as part of camel case or snake case variable names."
|
||||
def trim: sub("^\\s+";"") | sub("\\s+$";"");
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
def toCamel:
|
||||
trim as $snake
|
||||
| { camel: "", underscore : false}
|
||||
| reduce ($snake|explode[]|[.]|implode) as $c (.;
|
||||
if ["_", "-", " "]|index($c)
|
||||
then .underscore = true
|
||||
elif .underscore
|
||||
then .camel += ($c|ascii_upcase)
|
||||
| .underscore = false
|
||||
else .camel += $c
|
||||
end)
|
||||
| .camel;
|
||||
|
||||
def toSnake:
|
||||
(trim | gsub("\\s"; "_")) as $camel
|
||||
| reduce ($camel|explode[1:][]|[.]|implode) as $c (
|
||||
$camel[0:1];
|
||||
if $c|isUpper
|
||||
then ($c|ascii_downcase) as $lc
|
||||
| if (.[-1:] | (. == "_" or . == "-"))
|
||||
then . + $lc
|
||||
else . + "_" + $lc
|
||||
end
|
||||
else . + $c
|
||||
end );
|
||||
|
||||
def tests: [
|
||||
"snakeCase", "snake_case", "variable_10_case", "variable10Case", "ɛrgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "
|
||||
];
|
||||
|
||||
" === to_snake_case ===",
|
||||
(tests[] | "\(lpad(33)) -> \(toSnake)"),
|
||||
"",
|
||||
" === toCamelCase ===",
|
||||
(tests[] | "\(lpad(33)) -> \(toCamel)")
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#=
|
||||
Regex based variable name convention change string functions.
|
||||
`sep` is the separator targeted for change from (to camel case) or to (to snake case)
|
||||
`allsep` is the separators other than `sep` that may be changed to `sep`
|
||||
`lcmiddle` is a boolean to set whether caps within camel case words are made lowercase
|
||||
=#
|
||||
|
||||
function snakeToCamelCase(s; sep=r"[_]+", lcmiddle=false)
|
||||
isempty(s) && return s
|
||||
words = split(strip(s), sep)
|
||||
return lowercasefirst(join(uppercasefirst.(lcmiddle ? lowercase.(words) : words)))
|
||||
end
|
||||
|
||||
spaceToCamelCase(s) = snakeToCamelCase(s; sep=r"\s+")
|
||||
kebabToCamelCase(s) = snakeToCamelCase(s; sep=r"[\-]+")
|
||||
periodToCamelCase(s) = snakeToCamelCase(s; sep=r"[\.]+")
|
||||
allsepToCamelCase(s) = snakeToCamelCase(s; sep=r"[ \-_\.]+")
|
||||
lowermiddle_allsepToCamelCase(s) = snakeToCamelCase(s; sep=r"[ \-_\.]+", lcmiddle=true)
|
||||
|
||||
function camel_to_snake_case(s; sep="_", insep=sep, allsep=r"_+", lcmiddle=true)
|
||||
s = isempty(s) ? (return s) : lowercasefirst(strip(s))
|
||||
s = replace(s, r"[A-Z]+" => x -> sep * (lcmiddle ? lowercase(x) : lowercasefirst(x)))
|
||||
return replace(s, allsep => sep)
|
||||
end
|
||||
|
||||
preserve_midcaps_camel_to_snake_case(s) = camel_to_snake_case(s; lcmiddle=false)
|
||||
allsep_to_snake_case(s) = camel_to_snake_case(s; allsep=r"[ \-\._]+")
|
||||
allsep_to_kebab_case(s) = camel_to_snake_case(s; allsep=r"[ \-\._]+", sep="-")
|
||||
allsep_to_space_case(s) = camel_to_snake_case(s; allsep=r"[ \-\._]+", sep=" ")
|
||||
allsep_to_period_case(s) = camel_to_snake_case(s; allsep=r"[ \-\._]+", sep=".")
|
||||
allsep_to_slash_case(s) = camel_to_snake_case(s; allsep=r"[ \-\._]+", sep="/")
|
||||
|
||||
for f in [
|
||||
snakeToCamelCase,
|
||||
spaceToCamelCase,
|
||||
kebabToCamelCase,
|
||||
periodToCamelCase,
|
||||
allsepToCamelCase,
|
||||
lowermiddle_allsepToCamelCase,
|
||||
camel_to_snake_case,
|
||||
preserve_midcaps_camel_to_snake_case,
|
||||
allsep_to_snake_case,
|
||||
allsep_to_kebab_case,
|
||||
allsep_to_space_case,
|
||||
allsep_to_period_case,
|
||||
allsep_to_slash_case,
|
||||
]
|
||||
println("Testing function $f:")
|
||||
|
||||
for teststring in [
|
||||
"snakeCase",
|
||||
"snake_case",
|
||||
"snake-case",
|
||||
"snake case",
|
||||
"snake CASE",
|
||||
"snake.case",
|
||||
"variable_10_case",
|
||||
"variable10Case",
|
||||
"ɛrgo rE tHis",
|
||||
"hurry-up-joe!",
|
||||
"c://my-docs/happy_Flag-Day/12.doc",
|
||||
" spaces ",
|
||||
]
|
||||
println(lpad(teststring, 36), " => ", f(teststring))
|
||||
end
|
||||
println()
|
||||
end
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
{def snake2camel
|
||||
{lambda {:w}
|
||||
{S.replace (?:_|-)(\w)
|
||||
by {span {@ style="text-transform:uppercase;"}$1}
|
||||
in :w}}}
|
||||
-> snake2camel
|
||||
|
||||
{def camel2snake
|
||||
{lambda {:w}
|
||||
{S.replace ([A-Z])
|
||||
by _{span {@ style="text-transform:lowercase;"}$1}
|
||||
in :w}}}
|
||||
-> camel2snake
|
||||
|
||||
{S.map snake2camel
|
||||
snake_case
|
||||
snake-case
|
||||
my_brave_new_world
|
||||
my_brave-new_world
|
||||
... and_so_on
|
||||
}
|
||||
-> snakeCase snakeCase myBraveNewWorld myBraveNewWorld ... andSoOn
|
||||
|
||||
{S.map camel2snake
|
||||
snakeCase
|
||||
myBraveNewWorld
|
||||
... andSoOn
|
||||
}
|
||||
-> snake_case my_brave_new_world ... and_so_on
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
local function escapeForPattern(str)
|
||||
return (str:gsub("[-+*^?$.%%()[%]]", "%%%0"))
|
||||
end
|
||||
|
||||
local function toCamelCase(str, separator)
|
||||
local escapedSeparator = escapeForPattern(separator)
|
||||
local namePattern = "%l%w*"..escapedSeparator.."[%w"..escapedSeparator.."]*%w" -- Starting with a lower case character and containing the separator character.
|
||||
local separatorPattern = escapedSeparator.."(%w)" -- Discard the separator and capture the alphanumeric character.
|
||||
|
||||
return (str:gsub(namePattern, function(name)
|
||||
return (name:gsub(separatorPattern, string.upper)) -- The captured character will be the one argument for string.upper().
|
||||
end))
|
||||
end
|
||||
|
||||
local function fromCamelCase(str, separator)
|
||||
local namePattern = "%l+[%u%d]%w*" -- Starting with a lower case character and containing an upper case character or digit.
|
||||
local separatorPattern1 = "(%l)([%u%d])" -- Lower case character followed by upper case character or digit.
|
||||
local separatorPattern2 = "(%d)(%a)" -- Digit followed by alphanumeric character.
|
||||
|
||||
return (str:gsub(namePattern, function(name)
|
||||
return (name
|
||||
:gsub(separatorPattern1, function(char1,char2) return char1..separator..char2:lower() end)
|
||||
:gsub(separatorPattern2, function(char1,char2) return char1..separator..char2:lower() end)
|
||||
)
|
||||
end))
|
||||
end
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
local function utf8Length(str)
|
||||
local len = 0
|
||||
for char in str:gmatch"[\1-\127\194-\244][\128-\191]*" do
|
||||
len = len + 1
|
||||
end
|
||||
return len
|
||||
end
|
||||
|
||||
local tests = {
|
||||
"snakeCase", "snake_case",
|
||||
"variable_10_case", "variable10Case",
|
||||
"ɛrgo rE tHis",
|
||||
"hurry-up-joe!",
|
||||
"c://my-docs/happy_Flag-Day/12.doc",
|
||||
" spaces ",
|
||||
" internal space ",
|
||||
}
|
||||
|
||||
local function convert(label, converter)
|
||||
print(label..":")
|
||||
for _, str in ipairs(tests) do
|
||||
print((" "):rep(35-utf8Length(str)) .. str .. " => " .. converter(str))
|
||||
end
|
||||
print()
|
||||
end
|
||||
|
||||
convert("snake_case to camelCase", function(str) return toCamelCase (str, "_") end)
|
||||
convert("space case to camelCase", function(str) return toCamelCase (str, " ") end)
|
||||
convert("kebab-case to camelCase", function(str) return toCamelCase (str, "-") end)
|
||||
convert("camelCase to snake_case", function(str) return fromCamelCase(str, "_") end)
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
import std/[strformat, strutils, unicode]
|
||||
|
||||
const Delimiters = [Rune('_'), Rune('-'), Rune(' ')]
|
||||
|
||||
func toCamelCase(s: string): string =
|
||||
let s = s.strip(chars = Whitespace)
|
||||
var prev = Rune(0)
|
||||
for rune in s.runes:
|
||||
if prev in Delimiters:
|
||||
result.add rune.toUpper
|
||||
elif rune notin Delimiters:
|
||||
result.add rune
|
||||
prev = rune
|
||||
|
||||
func toSnakeCase(s: string): string =
|
||||
var s= s.strip(chars = Whitespace).replace(' ', '_')
|
||||
var idx = 0
|
||||
var prev = Rune(0)
|
||||
for rune in s.runes:
|
||||
if rune.isUpper and idx > 0:
|
||||
if prev notin Delimiters:
|
||||
result.add '_'
|
||||
result.add rune.toLower
|
||||
else:
|
||||
result.add rune
|
||||
prev = rune
|
||||
inc idx
|
||||
|
||||
const Strings = ["snakeCase", "snake_case", "variable_10_case",
|
||||
"variable10Case", "ɛrgo rE tHis", "hurry-up-joe!",
|
||||
"c://my-docs/happy_Flag-Day/12.doc", " spaces "]
|
||||
|
||||
echo center("### To snake case ###", 69)
|
||||
for s in Strings:
|
||||
echo &"{s:>33} → {s.toSnakeCase}"
|
||||
|
||||
echo()
|
||||
echo center("### To camel case ###", 69)
|
||||
for s in Strings:
|
||||
echo &"{s:>33} → {s.toCamelCase}"
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict; # https://rosettacode.org/wiki/Camel_case_and_snake_case
|
||||
use warnings;
|
||||
|
||||
my @words = (
|
||||
"snakeCase", "snake_case", "variable_10_case", "variable10Case", "#rgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "
|
||||
);
|
||||
|
||||
sub tosnake
|
||||
{
|
||||
shift =~ s/^ +| +$//gr =~ s/[A-Z]/_\l$&/gr =~ tr/ -/_/r =~ s/__+/_/gr;
|
||||
}
|
||||
|
||||
sub tocamel
|
||||
{
|
||||
shift =~ s/^ +| +$//gr =~ s/[ _-]([a-z0-9])/\u$1/gir;
|
||||
}
|
||||
|
||||
print "to snake case\n\n";
|
||||
for my $word ( @words )
|
||||
{
|
||||
printf "%35s -> %s\n", $word, tosnake($word);
|
||||
}
|
||||
|
||||
print "\nto camel case\n\n";
|
||||
for my $word ( @words )
|
||||
{
|
||||
printf "%35s -> %s\n", $word, tocamel($word);
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">to_snake_case</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">snake</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"_"</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">snake</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">isupper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">snake</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">snake</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'_'</span><span style="color: #0000FF;">&</span><span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">snake</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">snake</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">toCamelCase</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">camel</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"- "</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"__"</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">camel</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">camel</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]=</span><span style="color: #008000;">'_'</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">camel</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">camel</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">camel</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"snakeCase"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"snake_case"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"variable_10_case"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"variable10Case"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"ergo rE tHis"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #008000;">"hurry-up-joe!"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"c://my-docs/happy_Flag-Day/12.doc"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">" spaces "</span><span style="color: #0000FF;">}</span>
|
||||
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">title</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">title</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%33s ===> %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])})</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
|
||||
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">" === to_snake_case ===\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">to_snake_case</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"\n === toCamelCase ===\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">toCamelCase</span><span style="color: #0000FF;">)</span>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
""" https://rosettacode.org/wiki/Camel_case_and_snake_case """
|
||||
|
||||
import re
|
||||
|
||||
def snakeToCamelCase(nam, sep='[_]+', lcmiddle=False):
|
||||
""" convert snake '_' separator case to camel case """
|
||||
if nam == '':
|
||||
return nam
|
||||
words = re.split(sep, nam.strip())
|
||||
if lcmiddle:
|
||||
words = [w.lower() for w in words]
|
||||
words[1:] = [w[0].upper() + w[1:] for w in words[1:] if len(w) > 0]
|
||||
return ''.join(words)
|
||||
|
||||
|
||||
def spaceToCamelCase(nam):
|
||||
""" convert space case to camel case """
|
||||
return snakeToCamelCase(nam, sep='\s+')
|
||||
|
||||
def kebabToCamelCase(nam):
|
||||
""" convert kebab '-' case to camel case """
|
||||
return snakeToCamelCase(nam, sep='[\-]+')
|
||||
|
||||
def periodToCamelCase(nam):
|
||||
""" convert period '.' case to camel case """
|
||||
return snakeToCamelCase(nam, sep='[\.]+')
|
||||
|
||||
def allsepToCamelCase(nam):
|
||||
""" convert all separators in allsep to camel case """
|
||||
return snakeToCamelCase(nam, sep='[ \-_\.]+')
|
||||
|
||||
def lowermiddle_allsepToCamelCase(nam):
|
||||
""" convert all separators to camel case, and all but word starts to lowercase """
|
||||
return snakeToCamelCase(nam, sep='[ \-_\.]+', lcmiddle=True)
|
||||
|
||||
def camel_to_snake_case(nam, sep='_', allsep='[_]+', lcmiddle=True):
|
||||
""" convert camel case to snake case (separate with '_') """
|
||||
nam = re.sub('([A-Z]+)', sep + r"\1", nam.strip())
|
||||
sep1 = '\\' + sep if sep == '.' else sep
|
||||
if lcmiddle:
|
||||
nam = sep.join([w.lower() for w in nam.split(sep1) if len(w) > 0])
|
||||
else:
|
||||
nam = sep.join([w[0].lower() + w[1:] for w in nam.split(sep1) if len(w) > 0])
|
||||
return re.sub(allsep, sep, nam)
|
||||
|
||||
def preserve_midcaps_camel_to_snake_case(nam):
|
||||
return camel_to_snake_case(nam, lcmiddle=False)
|
||||
|
||||
def allsep_to_snake_case(nam):
|
||||
return camel_to_snake_case(nam, allsep='[ \-\._]+')
|
||||
|
||||
def allsep_to_kebab_case(nam):
|
||||
return camel_to_snake_case(nam, allsep='[ \-\._]+', sep='-')
|
||||
|
||||
def allsep_to_space_case(nam):
|
||||
return camel_to_snake_case(nam, allsep='[ \-\._]+', sep=' ')
|
||||
|
||||
def allsep_to_period_case(nam):
|
||||
return camel_to_snake_case(nam, allsep='[ \-\._]+', sep='.')
|
||||
|
||||
def allsep_to_slash_case(nam):
|
||||
return camel_to_snake_case(nam, allsep='[ \-\._]+', sep='/')
|
||||
|
||||
for f in [
|
||||
snakeToCamelCase,
|
||||
spaceToCamelCase,
|
||||
kebabToCamelCase,
|
||||
periodToCamelCase,
|
||||
allsepToCamelCase,
|
||||
lowermiddle_allsepToCamelCase,
|
||||
camel_to_snake_case,
|
||||
preserve_midcaps_camel_to_snake_case,
|
||||
allsep_to_snake_case,
|
||||
allsep_to_kebab_case,
|
||||
allsep_to_space_case,
|
||||
allsep_to_period_case,
|
||||
allsep_to_slash_case]:
|
||||
print(f"Testing function {f}:")
|
||||
for teststring in [
|
||||
"snakeCase",
|
||||
"snake_case",
|
||||
"snake-case",
|
||||
"snake case",
|
||||
"snake CASE",
|
||||
"snake.case",
|
||||
"variable_10_case",
|
||||
"variable10Case",
|
||||
"ɛrgo rE tHis",
|
||||
"hurry-up-joe!",
|
||||
"c://my-docs/happy_Flag-Day/12.doc",
|
||||
" spaces "]:
|
||||
print(teststring.rjust(36), " => ", f(teststring))
|
||||
print()
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
[ $ "_ -" find 3 < ] is separator ( c --> b )
|
||||
|
||||
[ dup lower != ] is capital ( c --> b )
|
||||
|
||||
[ 2 times [ reverse trim ]
|
||||
$ "" false rot
|
||||
witheach
|
||||
[ dup separator iff
|
||||
[ 2drop true ]
|
||||
else
|
||||
[ over if upper
|
||||
swap dip join
|
||||
drop false ] ]
|
||||
drop ] is camelise ( $ --> $ )
|
||||
|
||||
[ camelise
|
||||
$ "" swap
|
||||
witheach
|
||||
[ dup capital if
|
||||
[ dip
|
||||
[ char _ join ] ]
|
||||
lower join ] ] is snakify ( $ --> $ )
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#lang racket
|
||||
|
||||
(define input '("snakeCase" "snake_case" "variable_10_case" "variable10Case" "ɛrgo rE tHis" "hurry-up-joe!" "c://my-docs/happy_Flag-Day/12.doc" " spaces "))
|
||||
|
||||
;; make '-' the canonical separator by replacing '_' and ' ' with '-'
|
||||
(define (dashify s)
|
||||
(regexp-replace* #px"[_ ]" s "-"))
|
||||
|
||||
;; replace -X with -x for any upper-case X
|
||||
(define (dash-upper->dash-lower s)
|
||||
(regexp-replace* #px"-[[:upper:]]" s string-downcase))
|
||||
|
||||
;; replace X with -x for any upper-case X
|
||||
(define (upper->dash-lower s)
|
||||
(regexp-replace* #px"[[:upper:]]"
|
||||
s
|
||||
(λ (s) (string-append "-" (string-downcase s)))))
|
||||
|
||||
(define (string-kebabcase s)
|
||||
(upper->dash-lower (dash-upper->dash-lower (dashify s))))
|
||||
|
||||
(define (string-snakecase s)
|
||||
;; once we have kebabcase, snakecase is easy, just change '-' to '_'
|
||||
(regexp-replace* #px"-" (string-kebabcase s) "_"))
|
||||
|
||||
(define (string-camelcase s)
|
||||
;; camel is pretty easy, too - replace dash-anything with uppercase-anything
|
||||
;; note: this will change non-letters as well, so -10 becomes just 10
|
||||
(regexp-replace* #px"-." (string-kebabcase s) (λ (s) (string-upcase (substring s 1 2)))))
|
||||
|
||||
(define (convert-case to-case case-name namelist)
|
||||
(printf "Conversions to ~a:~n" case-name)
|
||||
(for ([name namelist])
|
||||
(printf "'~a' --> '~a'~n" name (to-case (string-trim name))))
|
||||
(printf "~n"))
|
||||
|
||||
(convert-case string-kebabcase "kebab-case" input)
|
||||
(convert-case string-snakecase "snake_case" input)
|
||||
(convert-case string-camelcase "camelCase" input)
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
my @tests = qww<>
|
||||
snakeCase snake_case variable_10_case variable10Case "ɛrgo rE tHis"
|
||||
hurry-up-joe! c://my-docs/happy_Flag-Day/12.doc " spaces "
|
||||
>;
|
||||
|
||||
|
||||
sub to_snake_case (Str $snake_case_string is copy) {
|
||||
$snake_case_string.=trim;
|
||||
return $snake_case_string if $snake_case_string.contains: / \s | '/' /;
|
||||
$snake_case_string.=subst: / <after <:Ll>> (<:Lu>|<:digit>+) /, {'_' ~ $0.lc}, :g;
|
||||
$snake_case_string.=subst: / <after <:digit>> (<:Lu>) /, {'_' ~ $0.lc}, :g;
|
||||
}
|
||||
|
||||
sub toCamelCase (Str $CamelCaseString is copy) {
|
||||
$CamelCaseString.=trim;
|
||||
return $CamelCaseString if $CamelCaseString.contains: / \s | '/' /;
|
||||
$CamelCaseString.=subst: / ('_') (\w) /, {$1.uc}, :g;
|
||||
}
|
||||
|
||||
sub to-kebab-case (Str $kebab-case-string is copy) {
|
||||
$kebab-case-string.=trim;
|
||||
return $kebab-case-string if $kebab-case-string.contains: / \s | '/' /;
|
||||
$kebab-case-string.=subst: / ('_') (\w) /, {'-' ~ $1.lc}, :g;
|
||||
$kebab-case-string.=subst: / <after <:Ll>> (<:Lu>|<:digit>+) /, {'-' ~ $0.lc}, :g;
|
||||
$kebab-case-string.=subst: / <after <:digit>> (<:Lu>) /, {'-' ~ $0.lc}, :g;
|
||||
}
|
||||
|
||||
say "{' ' x 30}to_snake_case";
|
||||
printf "%33s ==> %s\n", $_, .&to_snake_case for @tests;
|
||||
say "\n{' ' x 30}toCamelCase";
|
||||
printf "%33s ==> %s\n", $_, .&toCamelCase for @tests;
|
||||
say "\n{' ' x 30}to-kabab-case";
|
||||
printf "%33s ==> %s\n", $_, .&to-kebab-case for @tests;
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
fn to_camel(snake string) string {
|
||||
mut camel := ''
|
||||
mut underscore := false
|
||||
letters := snake.trim(' ').runes()
|
||||
for c in letters {
|
||||
if c.str() in [' ','-','_'] {
|
||||
underscore = true
|
||||
} else if underscore {
|
||||
camel += c.str().to_upper()
|
||||
underscore = false
|
||||
} else {
|
||||
camel += c.str()
|
||||
}
|
||||
}
|
||||
return camel
|
||||
}
|
||||
fn to_snake(camel string) string {
|
||||
mut snake := ''
|
||||
mut first := true
|
||||
letters := camel.trim(' ').replace(' ','_').runes()
|
||||
for c in letters {
|
||||
if first {
|
||||
snake+=c.str()
|
||||
first = false
|
||||
} else if !first && (c.str().is_upper() && c.bytes().len ==1 && c.bytes()[0].is_letter()) {
|
||||
if snake[snake.len-1..snake.len] == '_' || snake[snake.len-1..snake.len] == '-' {
|
||||
snake += c.str().to_lower()
|
||||
}else {
|
||||
snake += '_'+c.str().to_lower()
|
||||
}
|
||||
}else{
|
||||
snake+=c.str()
|
||||
}
|
||||
}
|
||||
return snake
|
||||
}
|
||||
const tests = ["snakeCase", "snake_case", "variable_10_case", "variable10Case", "ɛrgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "]
|
||||
fn main() {
|
||||
println(' === to_snake_case ===')
|
||||
for word in tests {
|
||||
println('${word:33} -> ${to_snake(word)}')
|
||||
}
|
||||
println(' === to_camel_case ===')
|
||||
for word in tests {
|
||||
println('${word:33} -> ${to_camel(word)}')
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
import "./str" for Char
|
||||
import "/fmt" for Fmt
|
||||
|
||||
var toCamel = Fn.new { |snake|
|
||||
snake = snake.trim()
|
||||
var camel = ""
|
||||
var underscore = false
|
||||
for (c in snake) {
|
||||
if ("_- ".contains(c)) {
|
||||
underscore = true
|
||||
} else if (underscore) {
|
||||
camel = camel + Char.upper(c)
|
||||
underscore = false
|
||||
} else {
|
||||
camel = camel + c
|
||||
}
|
||||
}
|
||||
return camel
|
||||
}
|
||||
|
||||
var toSnake = Fn.new { |camel|
|
||||
camel = camel.trim().replace(" ", "_") // we don't want any spaces in the result
|
||||
var snake = ""
|
||||
var first = true
|
||||
for (c in camel) {
|
||||
if (first) {
|
||||
snake = snake + c
|
||||
first = false
|
||||
} else if (!first && Char.isUpper(c)) {
|
||||
if (snake[-1] == "_" || snake[-1] == "-") {
|
||||
snake = snake + Char.lower(c)
|
||||
} else {
|
||||
snake = snake + "_" + Char.lower(c)
|
||||
}
|
||||
} else {
|
||||
snake = snake + c
|
||||
}
|
||||
}
|
||||
return snake
|
||||
}
|
||||
|
||||
var tests = [
|
||||
"snakeCase", "snake_case", "variable_10_case", "variable10Case", "ɛrgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "
|
||||
]
|
||||
|
||||
System.print(" === to_snake_case ===")
|
||||
for (camel in tests) {
|
||||
Fmt.print("$33s -> $s", camel, toSnake.call(camel))
|
||||
}
|
||||
|
||||
System.print("\n === toCamelCase ===")
|
||||
for (snake in tests) {
|
||||
Fmt.print("$33s -> $s", snake, toCamel.call(snake))
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
string 0; \use zero-terminated strings
|
||||
char Out(100); \output string (made global for safety)
|
||||
|
||||
func Trim(Str); \Trim leading and trailing spaces from string
|
||||
char Str;
|
||||
int I;
|
||||
[while Str(0) = $20 do Str:= Str+1; \skip leading spaces
|
||||
I:= 0; \skip to end of string (+1)
|
||||
while Str(I) # 0 do I:= I+1;
|
||||
while I>0 & Str(I-1)=$20 do I:= I-1; \skip back to first non-space
|
||||
Str(I):= 0; \chop off any trailing spaces
|
||||
return Str;
|
||||
];
|
||||
|
||||
func ToSnake(In); \Convert string to snake_case
|
||||
char In;
|
||||
int I, J, C, UL;
|
||||
[I:= 0; J:= 0; UL:= true; \suppress leading & redundant underlines
|
||||
repeat C:= In(I); I:= I+1; \get character from input string
|
||||
if C>=^A & C<=^Z then \convert uppercase to "_" + lowercase
|
||||
[if not UL then [Out(J):= ^_; J:= J+1];
|
||||
Out(J):= C+$20; J:= J+1;
|
||||
UL:= false;
|
||||
]
|
||||
else if C=$20 or C=^- then \convert to underlines
|
||||
[if not UL then [Out(J):= ^_; J:= J+1; UL:= true]
|
||||
]
|
||||
else [Out(J):= C; J:= J+1; UL:= C=^_];
|
||||
until C = 0;
|
||||
return Out;
|
||||
];
|
||||
|
||||
func ToCamel(In); \Convert string to camelCase
|
||||
char In;
|
||||
int I, J, C;
|
||||
[I:= 0; J:= 0;
|
||||
repeat C:= In(I); I:= I+1;
|
||||
if C=^_ or C=^- or C=$20 then
|
||||
[C:= In(I); I:= I+1;
|
||||
if C>=^a & C<=^z then C:= C-$20;
|
||||
Out(J):= C; J:= J+1;
|
||||
]
|
||||
else [Out(J):= C; J:= J+1];
|
||||
until C = 0;
|
||||
return Out;
|
||||
];
|
||||
|
||||
int Strings, I;
|
||||
[Strings:= [
|
||||
"snakeCase", "snake_case", "variable_10_case", "variable10Case", "\u025brgo rE tHis",
|
||||
"hurry-up-joe!", "c://my-docs/happy_Flag-Day/12.doc", " spaces "];
|
||||
Text(0, "To snake case:^M^J");
|
||||
for I:= 0 to 7 do
|
||||
[Text(0, Strings(I));
|
||||
Text(0, " -> ");
|
||||
Text(0, ToSnake(Trim(Strings(I))));
|
||||
CrLf(0);
|
||||
];
|
||||
Text(0, "To camel case:^M^J");
|
||||
for I:= 0 to 7 do
|
||||
[Text(0, Strings(I));
|
||||
Text(0, " -> ");
|
||||
Text(0, ToCamel(Trim(Strings(I))));
|
||||
CrLf(0);
|
||||
];
|
||||
]
|
||||
Loading…
Add table
Add a link
Reference in a new issue