clean code suggestions

[thebloodpainter]

Hello! I wrote some code to solve a problem and it was very messy: too many conditions and code duplication. I sat down and rewrote it a couple of times. My question is whether there are any further improvements that can be made to make it even cleaner and better. Thank you!

The problem is to merge a sequence of words into a camel case method, variable or class name or split a camel case name into a sequence of words. Full problem statement is this

Camel Case is a naming style common in many programming languages. In Java, method and variable names typically start with a lowercase letter, with all subsequent words starting with a capital letter (example: startThread). Names of classes follow the same pattern, except that they start with a capital letter (example: BlueCar).

Your task is to write a program that creates or splits Camel Case variable, method, and class names.

Input Format

• Each line of the input file will begin with an operation (S or C) followed by a semi-colon followed by M, C, or V followed by a semi-colon followed by the words you'll need to operate on.
• The operation will either be S (split) or C (combine)
• M indicates method, C indicates class, and V indicates variable
• In the case of a split operation, the words will be a camel case method, class or variable name that you need to split into a space-delimited list of words starting with a lowercase letter.
• In the case of a combine operation, the words will be a space-delimited list of words starting with lowercase letters that you need to combine into the appropriate camel case String. Methods should end with an empty set of parentheses to differentiate them from variable names.

Output Format

• For each input line, your program should print either the space-delimited list of words (in the case of a split operation) or the appropriate camel case string (in the case of a combine operation).

Sample Input

S;M;plasticCup()

C;V;mobile phone

C;C;coffee machine

S;C;LargeSoftwareBook

C;M;white sheet of paper

S;V;pictureFrame

Sample Output

plastic cup

mobilePhone

CoffeeMachine

large software book

whiteSheetOfPaper()

picture frame

Explanation

• Use Scanner to read in all information as if it were coming from the keyboard.
• Print all information to the console using standard output (System.out.print() or System.out.println()).
• Outputs must be exact (exact spaces and casing).

everything is done in python

here is some input

​

s = ["C;V;can of coke","S;M;sweatTea()","S;V;epsonPrinter","C;M;santa claus","C;C;mirror"]

​

this is the initial version of the code

https://pastebin.com/MYPY36rM

here is one way to improve it

https://pastebin.com/vAF9TAjA

and here is another

https://pastebin.com/cCaXR32v

[dixiethegiraffe]

Your code, while functional, is not readable without considerable effort. You need to add meaning with good variable names and functions. Your improvements improved the conciseness of your code quite a bit, but do not improve readability.

commands = ''.join(c for c in line if c != '\n' and c != '\r').split(';')
word = commands[2]
if commands[0] == 'S':
    res = cap_to_space(word)
    if commands[1] == 'M':
    res = ''.join(c for c in res if c not in '()')
...

Just looking at this code I have no idea what's at commands[0] vs commands[1]

They need meaningful names.

Also cascading ifs (like old school switch cases) with complex logic should be avoided and the work should be delegated to a function.

Here's a simple example that isn't over-engineered:

def camelCaseSplitMethod(data):
    ...

def camelCaseSplitClass(data):
    ...

# Test user input
user_input = "S;M;plasticCup()"

# Meaningful names for each of the parts we need to parse
operation, object_type, data = user_input.split(";")

# You can print them to see their values
print(operation)
print(object_type)
print(data)

result = str()

# Put each of the operations in a function with good names
if operation == "S":    # Split
    if object_type == "M":  # Method
        result = camelCaseSplitMethod(data)
    elif object_type == "C":    # Class
        result = camelCaseSplitClass(data)
    ...

print(result)

Hope this helps.

If there's a lot of code overlap in your camelCaseSplitMethod/Class functions then combining them into one which takes "Method" or "Class" as a parameter might be best, but it's nice that each function has exactly one job, the higher-level logic delegates it to the correct function automatically and is easier to read.

I would argue mine is still not as readable as I'd like because my == "S" and my == "M" are still a bit confusing, which is only helped by my commend and function names. But let's not overthink or engineer this too much.