josiadmin/awesome-copilot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

better account for incompatible code block indents

Browse Source
This commit is contained in:
jhauga 2025-11-03 20:59:27 -05:00
parent 73c626d041
commit fb96172b55
2 changed files with 165 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

259
instructions/object-calisthenics.instructions.md
View File

@ -8,9 +8,11 @@ description: Enforces Object Calisthenics principles for business domain code to
> Examples may be added later if needed. > Examples may be added later if needed.
## Objective ## Objective
This rule enforces the principles of Object Calisthenics to ensure clean, maintainable, and robust code in the backend, **primarily for business domain code**. This rule enforces the principles of Object Calisthenics to ensure clean, maintainable, and robust code in the backend, **primarily for business domain code**.
## Scope and Application ## Scope and Application
- **Primary focus**: Business domain classes (aggregates, entities, value objects, domain services) - **Primary focus**: Business domain classes (aggregates, entities, value objects, domain services)
- **Secondary focus**: Application layer services and use case handlers - **Secondary focus**: Application layer services and use case handlers
- **Exemptions**: - **Exemptions**:
@ -22,7 +24,6 @@ This rule enforces the principles of Object Calisthenics to ensure clean, mainta
## Key Principles ## Key Principles
1. **One Level of Indentation per Method**: 1. **One Level of Indentation per Method**:
- Ensure methods are simple and do not exceed one level of indentation. - Ensure methods are simple and do not exceed one level of indentation.
@ -57,6 +58,7 @@ This rule enforces the principles of Object Calisthenics to ensure clean, mainta
} }
} }
``` ```
2. **Don't Use the ELSE Keyword**: 2. **Don't Use the ELSE Keyword**:
- Avoid using the `else` keyword to reduce complexity and improve readability. - Avoid using the `else` keyword to reduce complexity and improve readability.
@ -81,6 +83,7 @@ This rule enforces the principles of Object Calisthenics to ensure clean, mainta
``` ```
Sample Fail fast principle: Sample Fail fast principle:
```csharp ```csharp
public void ProcessOrder(Order order) { public void ProcessOrder(Order order) {
if (order == null) throw new ArgumentNullException(nameof(order)); if (order == null) throw new ArgumentNullException(nameof(order));
@ -148,156 +151,156 @@ First Class Collections: a class that contains an array as an attribute should n
.Count(); .Count();
} }
} }
``` ```
5. **One Dot per Line**: 5. **One Dot per Line**:
- Limit the number of method calls in a single line to improve readability and maintainability. - Limit the number of method calls in a single line to improve readability and maintainability.
```csharp ```csharp
// Bad Example - Multiple dots in a single line // Bad Example - Multiple dots in a single line
public void ProcessOrder(Order order) { public void ProcessOrder(Order order) {
var userEmail = order.User.GetEmail().ToUpper().Trim(); var userEmail = order.User.GetEmail().ToUpper().Trim();
// Do something with userEmail // Do something with userEmail
} }
// Good Example - One dot per line // Good Example - One dot per line
public void ProcessOrder(Order order) { public void ProcessOrder(Order order) {
var user = order.User; var user = order.User;
var email = user.GetEmail(); var email = user.GetEmail();
var userEmail = email.ToUpper().Trim(); var userEmail = email.ToUpper().Trim();
// Do something with userEmail // Do something with userEmail
} }
``` ```
6. **Don't abbreviate**: 6. **Don't abbreviate**:
- Use meaningful names for classes, methods, and variables. - Use meaningful names for classes, methods, and variables.
- Avoid abbreviations that can lead to confusion. - Avoid abbreviations that can lead to confusion.
```csharp ```csharp
// Bad Example - Abbreviated names // Bad Example - Abbreviated names
public class U { public class U {
public string N { get; set; } public string N { get; set; }
} }
// Good Example - Meaningful names // Good Example - Meaningful names
public class User { public class User {
public string Name { get; set; } public string Name { get; set; }
} }
``` ```
7. **Keep entities small (Class, method, namespace or package)**: 7. **Keep entities small (Class, method, namespace or package)**:
- Limit the size of classes and methods to improve code readability and maintainability. - Limit the size of classes and methods to improve code readability and maintainability.
- Each class should have a single responsibility and be as small as possible. - Each class should have a single responsibility and be as small as possible.
Constraints: Constraints:
- Maximum 10 methods per class - Maximum 10 methods per class
- Maximum 50 lines per class - Maximum 50 lines per class
- Maximum 10 classes per package or namespace - Maximum 10 classes per package or namespace
```csharp ```csharp
// Bad Example - Large class with multiple responsibilities // Bad Example - Large class with multiple responsibilities
public class UserManager { public class UserManager {
public void CreateUser(string name) { /*...*/ } public void CreateUser(string name) { /*...*/ }
public void DeleteUser(int id) { /*...*/ } public void DeleteUser(int id) { /*...*/ }
public void SendEmail(string email) { /*...*/ } public void SendEmail(string email) { /*...*/ }
} }
// Good Example - Small classes with single responsibility // Good Example - Small classes with single responsibility
public class UserCreator { public class UserCreator {
public void CreateUser(string name) { /*...*/ } public void CreateUser(string name) { /*...*/ }
} }
public class UserDeleter { public class UserDeleter {
public void DeleteUser(int id) { /*...*/ } public void DeleteUser(int id) { /*...*/ }
} }
public class UserUpdater { public class UserUpdater {
public void UpdateUser(int id, string name) { /*...*/ } public void UpdateUser(int id, string name) { /*...*/ }
} }
``` ```
8. **No Classes with More Than Two Instance Variables**:
- Encourage classes to have a single responsibility by limiting the number of instance variables.
- Limit the number of instance variables to two to maintain simplicity.
- Do not count ILogger or any other logger as instance variable.
8. **No Classes with More Than Two Instance Variables**: ```csharp
- Encourage classes to have a single responsibility by limiting the number of instance variables. // Bad Example - Class with multiple instance variables
- Limit the number of instance variables to two to maintain simplicity. public class UserCreateCommandHandler {
- Do not count ILogger or any other logger as instance variable. // Bad: Too many instance variables
private readonly IUserRepository userRepository;
private readonly IEmailService emailService;
private readonly ILogger logger;
private readonly ISmsService smsService;
```csharp public UserCreateCommandHandler(IUserRepository userRepository, IEmailService emailService, ILogger logger, ISmsService smsService) {
// Bad Example - Class with multiple instance variables this.userRepository = userRepository;
public class UserCreateCommandHandler { this.emailService = emailService;
// Bad: Too many instance variables this.logger = logger;
private readonly IUserRepository userRepository; this.smsService = smsService;
private readonly IEmailService emailService; }
private readonly ILogger logger; }
private readonly ISmsService smsService;
public UserCreateCommandHandler(IUserRepository userRepository, IEmailService emailService, ILogger logger, ISmsService smsService) { // Good: Class with two instance variables
this.userRepository = userRepository; public class UserCreateCommandHandler {
this.emailService = emailService; private readonly IUserRepository userRepository;
this.logger = logger; private readonly INotificationService notificationService;
this.smsService = smsService; private readonly ILogger logger; // This is not counted as instance variable
}
}
// Good: Class with two instance variables public UserCreateCommandHandler(IUserRepository userRepository, INotificationService notificationService, ILogger logger) {
public class UserCreateCommandHandler { this.userRepository = userRepository;
private readonly IUserRepository userRepository; this.notificationService = notificationService;
private readonly INotificationService notificationService; this.logger = logger;
private readonly ILogger logger; // This is not counted as instance variable }
}
```
public UserCreateCommandHandler(IUserRepository userRepository, INotificationService notificationService, ILogger logger) { 9. **No Getters/Setters in Domain Classes**:
this.userRepository = userRepository; - Avoid exposing setters for properties in domain classes.
this.notificationService = notificationService; - Use private constructors and static factory methods for object creation.
this.logger = logger; - **Note**: This rule applies primarily to domain classes, not DTOs or data transfer objects.
}
}
```
9. **No Getters/Setters in Domain Classes**: ```csharp
- Avoid exposing setters for properties in domain classes. // Bad Example - Domain class with public setters
- Use private constructors and static factory methods for object creation. public class User { // Domain class
- **Note**: This rule applies primarily to domain classes, not DTOs or data transfer objects. public string Name { get; set; } // Avoid this in domain classes
}
```csharp // Good Example - Domain class with encapsulation
// Bad Example - Domain class with public setters public class User { // Domain class
public class User { // Domain class private string name;
public string Name { get; set; } // Avoid this in domain classes private User(string name) { this.name = name; }
} public static User Create(string name) => new User(name);
}
// Good Example - Domain class with encapsulation // Acceptable Example - DTO with public setters
public class User { // Domain class public class UserDto { // DTO - exemption applies
private string name; public string Name { get; set; } // Acceptable for DTOs
private User(string name) { this.name = name; } }
public static User Create(string name) => new User(name); ```
}
// Acceptable Example - DTO with public setters ## Implementation Guidelines
public class UserDto { // DTO - exemption applies
public string Name { get; set; } // Acceptable for DTOs
}
```
## Implementation Guidelines - **Domain Classes**:
- **Domain Classes**: - Use private constructors and static factory methods for creating instances.
- Use private constructors and static factory methods for creating instances. - Avoid exposing setters for properties.
- Avoid exposing setters for properties. - Apply all 9 rules strictly for business domain code.
- Apply all 9 rules strictly for business domain code.
- **Application Layer**: - **Application Layer**:
- Apply these rules to use case handlers and application services. - Apply these rules to use case handlers and application services.
- Focus on maintaining single responsibility and clean abstractions. - Focus on maintaining single responsibility and clean abstractions.
- **DTOs and Data Objects**: - **DTOs and Data Objects**:
- Rules 3 (wrapping primitives), 8 (two instance variables), and 9 (no getters/setters) may be relaxed for DTOs. - Rules 3 (wrapping primitives), 8 (two instance variables), and 9 (no getters/setters) may be relaxed for DTOs.
- Public properties with getters/setters are acceptable for data transfer objects. - Public properties with getters/setters are acceptable for data transfer objects.
- **Testing**: - **Testing**:
- Ensure tests validate the behavior of objects rather than their state. - Ensure tests validate the behavior of objects rather than their state.
- Test classes may have relaxed rules for readability and maintainability. - Test classes may have relaxed rules for readability and maintainability.
- **Code Reviews**: - **Code Reviews**:
- Enforce these rules during code reviews for domain and application code. - Enforce these rules during code reviews for domain and application code.
- Be pragmatic about infrastructure and DTO code. - Be pragmatic about infrastructure and DTO code.
## References ## References
- [Object Calisthenics - Original 9 Rules by Jeff Bay](https://www.cs.helsinki.fi/u/luontola/tdd-2009/ext/ObjectCalisthenics.pdf)
- [ThoughtWorks - Object Calisthenics](https://www.thoughtworks.com/insights/blog/object-calisthenics)
- [Clean Code: A Handbook of Agile Software Craftsmanship - Robert C. Martin](https://www.oreilly.com/library/view/clean-code-a/9780136083238/)
- [Object Calisthenics - Original 9 Rules by Jeff Bay](https://www.cs.helsinki.fi/u/luontola/tdd-2009/ext/ObjectCalisthenics.pdf)
- [ThoughtWorks - Object Calisthenics](https://www.thoughtworks.com/insights/blog/object-calisthenics)
- [Clean Code: A Handbook of Agile Software Craftsmanship - Robert C. Martin](https://www.oreilly.com/library/view/clean-code-a/9780136083238/)

12
scripts/indent-nested-md-code.js
View File

@ -104,7 +104,17 @@ function processFile(filePath) {
continue; continue;
} }
// Otherwise, treat as nested inner fence start; indent til matching inner fence (inclusive) // Potential nested fence - check if it has language info (opening fence)
// If rest is empty or just whitespace, it's likely a sloppy closing fence, not a nested opening
const hasLangInfo = restTrim.length > 0;
if (!hasLangInfo) {
// Sloppy closing fence without nested content - don't indent, just skip
i++;
continue;
}
// This is an actual nested opening fence; indent til matching inner fence (inclusive)
changed = true; changed = true;
const innerTicksLen = ticksLen; const innerTicksLen = ticksLen;
lines[i] = ' ' + lines[i]; lines[i] = ' ' + lines[i];