ക്ലാങ് ഫോർമാറ്റ് ഇൻഡൻ്റേഷൻ ഉപയോഗിച്ച് C++ ചെയിൻഡ് മെത്തേഡ് കോളുകൾ എങ്ങനെ വിന്യസിക്കാം

പെർഫെക്റ്റ് ഇൻഡൻ്റേഷനായി മാസ്റ്ററിംഗ് ക്ലാങ് ഫോർമാറ്റ്

എല്ലാ ഡവലപ്പർമാരും വൃത്തിയുള്ളതും വായിക്കാനാകുന്നതുമായ കോഡ് ഇഷ്ടപ്പെടുന്നു, പ്രത്യേകിച്ച് പ്രവർത്തിക്കുമ്പോൾ ചങ്ങലയുള്ള രീതി കോളുകൾ C++ ൽ. എന്നിരുന്നാലും, നമ്മൾ എല്ലാവരും ഇതുപോലുള്ള ഉപകരണങ്ങൾ നേരിട്ടു clang-format ചിലപ്പോഴൊക്കെ നമ്മൾ ഇഷ്ടപ്പെടുന്ന രീതിയിൽ കോഡ് വിന്യസിക്കാൻ വിസമ്മതിക്കുന്നു. മുമ്പത്തെ ലൈനുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ മനോഹരമായി വിന്യസിക്കാൻ ചങ്ങലയുള്ള രീതികളുടെ ഇൻഡൻ്റേഷൻ നേടുക എന്നതാണ് ഒരു പൊതു വെല്ലുവിളി, ആരംഭ പ്രവർത്തനമല്ല.

നിങ്ങൾ ഒരു ബിൽഡർ പാറ്റേൺ ഉപയോഗിച്ച് ഒരു വസ്തു നിർമ്മിക്കുകയാണെന്ന് സങ്കൽപ്പിക്കുക. നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു വൃത്തിയുള്ള ഔട്ട്പുട്ട് വേണം:

ഓട്ടോ foo = FooBuilder()
.എന്തെങ്കിലും കൂടെ()
.മറ്റൊന്നിനൊപ്പം()
.ബിൽഡ്();

എന്നാൽ ക്ലീൻ കോഡ് വലിച്ചുനീട്ടിയ കുഴപ്പമാക്കി മാറ്റിക്കൊണ്ട്, നിങ്ങളുടെ രീതികൾ വലതുവശത്തേക്ക് തള്ളാൻ ക്ലാങ് ഫോർമാറ്റ് നിർബന്ധിക്കുന്നു. പെട്ടെന്ന്, ഒരിക്കൽ ക്രമീകരിച്ച നിങ്ങളുടെ വരികൾ പൊരുത്തമില്ലാത്തതായി തോന്നുന്നു, ദൃശ്യപ്രവാഹം തകർന്നിരിക്കുന്നു. നിരാശാജനകമാണ്, അല്ലേ? 🤯

ഒരു API സേവനം റീഫാക്‌ടർ ചെയ്യുമ്പോൾ ഈ പ്രശ്‌നം നേരിട്ടതായി ഞാൻ ഓർക്കുന്നു. എൻ്റെ തികച്ചും വിന്യസിച്ച രീതിയിലുള്ള കോളുകൾ ഒരു ഗോവണിയോട് സാമ്യമുള്ള ഒന്നായി മാറി-ഓരോ വരിയും വലത്തേക്ക് തള്ളി. ഇത് കോഡ് അവലോകനങ്ങൾ കഠിനമാക്കുകയും എൻ്റെ കണ്ണുകൾ ക്ഷീണിക്കുകയും ചെയ്തു. ഈ ലേഖനത്തിൽ, ചെയിൻ കോളുകൾക്കുള്ള ക്ലാങ് ഫോർമാറ്റ് ഇൻഡൻ്റേഷനിൽ നിയന്ത്രണം വീണ്ടെടുക്കുന്നതിനുള്ള പ്രായോഗിക സ്ഥിതിവിവരക്കണക്കുകൾ ഞാൻ പങ്കിടും, അതുവഴി നിങ്ങളുടെ കോഡ് സ്റ്റൈലിഷും വായിക്കാവുന്നതുമായി തുടരും. 🛠️

# Step 1: Create a .clang-format file in your project root
# Step 2: Add the following configuration to control indentation
BasedOnStyle: Google
ContinuationIndentWidth: 4
AlignAfterOpenBracket: false
AllowShortFunctionsOnASingleLine: Empty
BreakBeforeBraces: Attach
# Align method calls relative to the previous line
ColumnLimit: 0 # Disables column wrapping
# Save and format your code

// Use clang-format directives to skip specific code regions
auto foo = FooBuilder()
    // clang-format off
    .WithSomething()
    .WithSomethingElse()
    .Build();
    // clang-format on
// clang-format will ignore indentation inside the marked section
// Useful for one-off adjustments without changing global settings
// Combine with other tools for consistency

import re
# Python script to reformat chained method calls
def adjust_indentation(input_file, output_file):
    with open(input_file, 'r') as f:
        lines = f.readlines()
    with open(output_file, 'w') as f_out:
        for line in lines:
            if re.search(r'^\s*\..*', line):
                f_out.write('    ' + line.strip() + '\n')
            else:
                f_out.write(line)
# Usage: adjust_indentation('input.cpp', 'output.cpp')

#include <gtest/gtest.h>
// Example function to validate chaining format
TEST(IndentationTest, ChainedMethods) {
    std::string expected =
        "auto foo = FooBuilder()\n"
        "    .WithSomething()\n"
        "    .WithSomethingElse()\n"
        "    .Build();";
    std::string actual = FooBuilder()
        .WithSomething()
        .WithSomethingElse()
        .Build();
    ASSERT_EQ(expected, actual);
}

കൃത്യമായ മെത്തേഡ് ചെയിനിംഗിനുള്ള ഫൈൻ-ട്യൂണിംഗ് ക്ലാങ് ഫോർമാറ്റ്

മുകളിൽ നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകളിൽ, എങ്ങനെ ക്രമീകരിക്കാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്തു clang-format C++-ൽ വായിക്കാവുന്നതും വൃത്തിയുള്ളതുമായ ചെയിൻഡ് രീതി കോളുകൾ നിലനിർത്താൻ. മുമ്പത്തെ ലൈനിനേക്കാൾ ആദ്യ ഫംഗ്‌ഷൻ ഇൻവോക്കേഷനുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ clang-format aligns method കോൾ ചെയ്യുന്നതിനാലാണ് ഈ പ്രശ്നം ഉണ്ടാകുന്നത്. ഇത് പരിഹരിക്കാൻ, ഞങ്ങൾ പ്രത്യേക കമാൻഡുകൾ ഉപയോഗിച്ചു ContinuationIndentWidth, തുടങ്ങിയ നിർദ്ദേശങ്ങൾ clang-format ഓഫ്/ഓൺ, പൈത്തണിൽ എഴുതിയ പോസ്റ്റ് പ്രോസസ്സിംഗ് സ്ക്രിപ്റ്റുകൾ. ഡെവലപ്പർമാർക്ക് പരമാവധി ഫ്ലെക്സിബിലിറ്റി ഉറപ്പാക്കാൻ ഓരോ രീതിയും അല്പം വ്യത്യസ്തമായ ഉപയോഗ കേസ് ലക്ഷ്യമിടുന്നു.

ഒരു സൃഷ്ടിക്കുന്നത് ഉൾപ്പെട്ടതാണ് ആദ്യ പരിഹാരം .ക്ലാങ്-ഫോർമാറ്റ് ഫയൽ. ഈ ഫയൽ ഡവലപ്പർമാരെ അവരുടെ C++ പ്രോജക്റ്റുകൾക്കായി ഫോർമാറ്റിംഗ് നിയമങ്ങൾ ഇഷ്ടാനുസൃതമാക്കാൻ അനുവദിക്കുന്നു. പ്രധാന ക്രമീകരണങ്ങൾ ഉൾപ്പെടുന്നു ContinuationIndentWidth, ഇത് ലൈൻ തുടർച്ചകൾക്കുള്ള ഇടങ്ങളുടെ എണ്ണം വ്യക്തമാക്കുന്നു, കൂടാതെ വിന്യസിക്കുകAfterOpenBracket, ബ്രാക്കറ്റുകൾക്ക് ശേഷം അനാവശ്യമായി കോഡ് വിന്യസിക്കുന്നതിൽ നിന്ന് clang-format തടയുന്നു. ഉദാഹരണത്തിന്, ക്രമീകരണം കോളത്തിൻ്റെ പരിധി: 0 ലൈൻ ബ്രേക്കിംഗ് അപ്രാപ്‌തമാക്കുന്നു, ചങ്ങലയുള്ള രീതികൾ ശരിയായി വിന്യസിച്ചിരിക്കുന്നതും ദൃശ്യപരമായി ആകർഷകവുമാണെന്ന് ഉറപ്പാക്കുന്നു.

രണ്ടാമത്തെ സമീപനത്തിൽ മാനുവൽ നിയന്ത്രണം ഉപയോഗിച്ചു clang-format ഓഫ്/ഓൺ നിർദ്ദേശങ്ങൾ. ഓട്ടോമാറ്റിക് ഫോർമാറ്റിംഗ് താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കുന്ന ഇൻലൈൻ കമൻ്റുകളാണിത്. മെത്തേഡ് ചെയിനുകൾക്ക് മുമ്പും ശേഷവും ഈ നിർദ്ദേശങ്ങൾ തന്ത്രപരമായി സ്ഥാപിക്കുന്നതിലൂടെ, ഡെവലപ്പർമാർ ഇൻഡൻ്റേഷൻ്റെ പൂർണ്ണ നിയന്ത്രണം വീണ്ടെടുക്കുന്നു. ഉദാഹരണത്തിന്, മെത്തേഡ് കോളുകൾക്ക് മുമ്പായി "// clang-format off" എന്നത് ക്ലാങ് ഫോർമാറ്റ് തടസ്സപ്പെടുത്തുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു, ആഗോള ക്രമീകരണങ്ങൾ അനുയോജ്യമല്ലാത്തപ്പോൾ ഇതൊരു പ്രായോഗിക ഒറ്റത്തവണ പരിഹാരമാക്കി മാറ്റുന്നു. മറ്റുള്ളവർക്ക് വ്യത്യസ്ത ഫോർമാറ്റിംഗ് നിയമങ്ങൾ ഉണ്ടായിരിക്കാവുന്ന സഹകരണ പരിതസ്ഥിതികളിൽ ഇത് പ്രത്യേകിച്ചും സഹായകരമാണ്. ✨

അവസാനമായി, ക്ലാങ് ഫോർമാറ്റ് റൺ ചെയ്തതിന് ശേഷമുള്ള പോസ്റ്റ്-പ്രോസസ് ഫോർമാറ്റിംഗ് പ്രശ്നങ്ങളിലേക്ക് ഞങ്ങൾ ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ് അവതരിപ്പിച്ചു. ഈ സ്‌ക്രിപ്റ്റ് ചെയിൻ ചെയ്‌ത രീതി കോളുകൾക്കായി സ്‌കാൻ ചെയ്യുകയും മുമ്പത്തെ ലൈനുമായി ബന്ധപ്പെട്ട സ്‌പെയ്‌സുകൾ ചേർത്ത് അവയുടെ ഇൻഡൻ്റേഷൻ ക്രമീകരിക്കുകയും ചെയ്യുന്നു. പതിവ് എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച്, സ്ക്രിപ്റ്റ് ഡോട്ടുകളിൽ ആരംഭിക്കുന്ന വരികൾ തിരിച്ചറിയുന്നു (ഉദാ. ".WithSomething()") കൂടാതെ സ്ഥിരമായ ഇൻഡൻ്റേഷൻ പ്രയോഗിക്കുന്നു. സ്വമേധയാലുള്ള ഇടപെടൽ സമയമെടുക്കുന്ന വലിയ കോഡ്ബേസുകൾക്ക് അത്തരം ഓട്ടോമേഷൻ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. കൂടാതെ, ഫോർമാറ്റ് ചെയ്‌ത കോഡ് ഉദ്ദേശിച്ച ശൈലിയുമായി പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് സാധൂകരിക്കുന്നതിന് Google ടെസ്റ്റിൽ എഴുതിയ യൂണിറ്റ് ടെസ്റ്റുകൾ ഞങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, ഇത് ഒന്നിലധികം പരിതസ്ഥിതികളിലുടനീളം കരുത്തുറ്റത ഉറപ്പാക്കുന്നു. 🛠️

ക്ലാങ് ഫോർമാറ്റ് ഉപയോഗിച്ച് ചെയിൻഡ് മെത്തേഡ് ഇൻഡൻ്റേഷൻ പെർഫെക്റ്റ് ചെയ്യുന്നു

ഉപയോഗിക്കുന്നതിൽ പലപ്പോഴും അവഗണിക്കപ്പെടുന്ന ഒരു വശം clang-format സങ്കീർണ്ണമായ കോഡ്ബേസുകളിൽ ചെയിൻ ചെയ്ത രീതി കോളുകളുമായുള്ള അതിൻ്റെ ഇടപെടലാണ്. ഞങ്ങൾ ബിൽഡർമാരുമായോ സുഗമമായ API-കളുമായോ ഇടപെടുമ്പോൾ, ശരിയായ വിന്യാസം വായനാക്ഷമത വർദ്ധിപ്പിക്കുന്നു. മുമ്പത്തെ ലൈനുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ രീതി ശൃംഖലകൾ വൃത്തിയായി വിന്യസിക്കണമെന്ന് ഡെവലപ്പർമാർ ആഗ്രഹിക്കുന്നു, എന്നാൽ ക്ലാങ് ഫോർമാറ്റിൻ്റെ ഡിഫോൾട്ട് സ്വഭാവം അടിസ്ഥാന രീതി അല്ലെങ്കിൽ ഫംഗ്‌ഷൻ കോളിന് കീഴിൽ അവയെ വിന്യസിക്കുന്നു. ഇത് മെത്തേഡ് ചെയിനിംഗിൻ്റെ ലോജിക്കൽ ഫ്ലോയെ തകർക്കുന്ന, അലങ്കോലപ്പെട്ടതും വായിക്കാൻ ബുദ്ധിമുട്ടുള്ളതുമായ കോഡിലേക്ക് നയിച്ചേക്കാം.

ഇത് പരിഹരിക്കുന്നതിന്, എങ്ങനെയെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ് clang-format കോഡ് പ്രോസസ്സ് ചെയ്യുന്നു. സ്ഥിരസ്ഥിതിയായി, ഇത് പോലുള്ള പരാമീറ്ററുകളെ ആശ്രയിക്കുന്നു ContinuationIndentWidth ഒപ്പം വിന്യസിക്കുകAfterOpenBracket. എന്നിരുന്നാലും, ഈ കോൺഫിഗറേഷനുകൾ മൾട്ടി-ലൈൻ കോളുകളെ പൂർണ്ണമായി നിയന്ത്രിക്കാനിടയില്ല. ഉദാഹരണത്തിന്, ക്രമീകരണം 0 വരെ 0 ഓട്ടോമാറ്റിക് ലൈൻ ബ്രേക്കിംഗ് തടയുന്നു, പക്ഷേ ഇൻഡൻ്റേഷൻ ശരിയാക്കുന്നില്ല. മികച്ച നിയന്ത്രണത്തിന്, പോലുള്ള നിർദ്ദേശങ്ങൾ // clang-format off ഒപ്പം // clang-format on കോഡിൻ്റെ പ്രത്യേക മേഖലകളിൽ ഫോർമാറ്റിംഗ് മറികടക്കാൻ തന്ത്രപരമായി സ്ഥാപിക്കാവുന്നതാണ്.

ചിലപ്പോൾ, ടീമുകളിലുടനീളം സ്ഥിരതയുള്ള ഫോർമാറ്റിംഗ് അനിവാര്യമായ പ്രോജക്റ്റുകൾക്ക്, പോസ്റ്റ്-പ്രോസസ്സിംഗ് സ്ക്രിപ്റ്റുകൾ അല്ലെങ്കിൽ ഇഷ്‌ടാനുസൃത IDE കോൺഫിഗറേഷനുകൾ പോലുള്ള ഉപകരണങ്ങൾ ആവശ്യമാണ്. ഉദാഹരണത്തിന്, ചെയിൻ കോളുകൾ കണ്ടെത്തുകയും ഇൻഡൻ്റേഷൻ പുനഃക്രമീകരിക്കുകയും ചെയ്യുന്ന ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ് ഒരു ബാക്കപ്പ് പരിഹാരമായി വർത്തിക്കും. ഈ സമീപനം അത് ഉറപ്പാക്കുന്നു clang-format അടയാളം നഷ്‌ടപ്പെടുന്നു, കോഡ് മാറ്റങ്ങൾക്ക് ശേഷം ഡവലപ്പർമാർക്ക് ആവശ്യമുള്ള ശൈലി സ്വയമേവ നടപ്പിലാക്കാൻ കഴിയും. 🚀