@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/roger-reviewer/samples/boolean-simplification-examples.md

@@ -0,0 +1,484 @@
+# Boolean Expression Simplification in AL - Code Examples
+
+## Overview
+Complex boolean expressions in AL code can significantly impact readability, maintainability, and performance. This sample demonstrates systematic approaches to simplifying boolean logic while maintaining functionality and improving code clarity.
+
+## Fundamental Simplification Patterns
+
+### Example 1: Basic De Morgan's Laws Application
+
+**Problematic Code:**
+```al
+procedure ValidateCustomerOrder(SalesHeader: Record "Sales Header"): Boolean
+var
+    Customer: Record Customer;
+begin
+    Customer.Get(SalesHeader."Sell-to Customer No.");
+
+    // Complex negative condition - hard to read and understand
+    if not (Customer.Blocked = Customer.Blocked::" ") or
+       not (SalesHeader.Status = SalesHeader.Status::Open) or
+       not (SalesHeader."Document Date" >= Today()) then
+        exit(false);
+
+    exit(true);
+end;
+```
+
+**Simplified Code:**
+```al
+procedure ValidateCustomerOrder(SalesHeader: Record "Sales Header"): Boolean
+var
+    Customer: Record Customer;
+    CustomerBlocked: Boolean;
+    OrderNotOpen: Boolean;
+    OrderDateInvalid: Boolean;
+begin
+    Customer.Get(SalesHeader."Sell-to Customer No.");
+
+    // Apply De Morgan's law: not (A or B or C) = (not A) and (not B) and (not C)
+    // Then simplify by removing double negatives
+    CustomerBlocked := Customer.Blocked <> Customer.Blocked::" ";
+    OrderNotOpen := SalesHeader.Status <> SalesHeader.Status::Open;
+    OrderDateInvalid := SalesHeader."Document Date" < Today();
+
+    // Clear positive logic: ALL conditions must be false for validation to pass
+    if CustomerBlocked or OrderNotOpen or OrderDateInvalid then
+        exit(false);
+
+    exit(true);
+end;
+```
+
+### Example 2: Condition Extraction and Grouping
+
+**Problematic Code:**
+```al
+procedure CanPostSalesDocument(SalesHeader: Record "Sales Header"): Boolean
+var
+    SalesLine: Record "Sales Line";
+    GeneralLedgerSetup: Record "General Ledger Setup";
+    UserSetup: Record "User Setup";
+begin
+    GeneralLedgerSetup.Get();
+    UserSetup.Get(UserId());
+
+    // Extremely complex boolean expression mixing different concerns
+    if (SalesHeader.Status = SalesHeader.Status::Released) and
+       (SalesHeader."Posting Date" <> 0D) and
+       (SalesHeader."Document Date" <> 0D) and
+       ((SalesHeader."Posting Date" >= GeneralLedgerSetup."Allow Posting From") and
+        (SalesHeader."Posting Date" <= GeneralLedgerSetup."Allow Posting To")) and
+       ((UserSetup."Allow Posting From" = 0D) or (SalesHeader."Posting Date" >= UserSetup."Allow Posting From")) and
+       ((UserSetup."Allow Posting To" = 0D) or (SalesHeader."Posting Date" <= UserSetup."Allow Posting To")) and
+       (SalesHeader."Sell-to Customer No." <> '') and
+       (SalesHeader.Amount > 0) then
+        exit(true)
+    else
+        exit(false);
+end;
+```
+
+**Simplified Code:**
+```al
+procedure CanPostSalesDocument(SalesHeader: Record "Sales Header"): Boolean
+begin
+    // Break complex validation into logical groups
+    if not IsDocumentStatusValid(SalesHeader) then
+        exit(false);
+
+    if not AreDatesValid(SalesHeader) then
+        exit(false);
+
+    if not IsPostingDateAllowed(SalesHeader."Posting Date") then
+        exit(false);
+
+    if not IsDocumentContentValid(SalesHeader) then
+        exit(false);
+
+    exit(true);
+end;
+
+local procedure IsDocumentStatusValid(SalesHeader: Record "Sales Header"): Boolean
+begin
+    exit(SalesHeader.Status = SalesHeader.Status::Released);
+end;
+
+local procedure AreDatesValid(SalesHeader: Record "Sales Header"): Boolean
+begin
+    exit((SalesHeader."Posting Date" <> 0D) and (SalesHeader."Document Date" <> 0D));
+end;
+
+local procedure IsPostingDateAllowed(PostingDate: Date): Boolean
+var
+    GeneralLedgerSetup: Record "General Ledger Setup";
+    UserSetup: Record "User Setup";
+begin
+    GeneralLedgerSetup.Get();
+
+    // Check system-wide posting date restrictions
+    if not ((PostingDate >= GeneralLedgerSetup."Allow Posting From") and
+            (PostingDate <= GeneralLedgerSetup."Allow Posting To")) then
+        exit(false);
+
+    // Check user-specific posting date restrictions
+    if UserSetup.Get(UserId()) then
+        exit(IsWithinUserDateRange(PostingDate, UserSetup));
+
+    exit(true);
+end;
+
+local procedure IsWithinUserDateRange(PostingDate: Date; UserSetup: Record "User Setup"): Boolean
+var
+    WithinFromDate: Boolean;
+    WithinToDate: Boolean;
+begin
+    WithinFromDate := (UserSetup."Allow Posting From" = 0D) or (PostingDate >= UserSetup."Allow Posting From");
+    WithinToDate := (UserSetup."Allow Posting To" = 0D) or (PostingDate <= UserSetup."Allow Posting To");
+
+    exit(WithinFromDate and WithinToDate);
+end;
+
+local procedure IsDocumentContentValid(SalesHeader: Record "Sales Header"): Boolean
+begin
+    exit((SalesHeader."Sell-to Customer No." <> '') and (SalesHeader.Amount > 0));
+end;
+```
+
+## Advanced Boolean Simplification Techniques
+
+### Example 3: Short-Circuit Evaluation Optimization
+
+**Problematic Code:**
+```al
+procedure ValidateItemForSale(ItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal): Boolean
+var
+    Item: Record Item;
+    ItemLedgerEntry: Record "Item Ledger Entry";
+    Location: Record Location;
+    StockkeepingUnit: Record "Stockkeeping Unit";
+    AvailableInventory: Decimal;
+    IsReserved: Boolean;
+    HasSpecialPricing: Boolean;
+begin
+    // Poor ordering - expensive operations performed regardless of simple checks
+    Item.Get(ItemNo);
+    Item.CalcFields(Inventory);
+    AvailableInventory := CalculateAvailableInventory(ItemNo, LocationCode);
+    IsReserved := CheckReservationStatus(ItemNo, LocationCode);
+    HasSpecialPricing := CheckSpecialPricing(ItemNo);
+    Location.Get(LocationCode);
+
+    if (Item.Blocked = false) and
+       (Item.Type = Item.Type::Inventory) and
+       (Location."Use As In-Transit" = false) and
+       (Quantity > 0) and
+       (AvailableInventory >= Quantity) and
+       (IsReserved = false) and
+       (HasSpecialPricing = true) then
+        exit(true)
+    else
+        exit(false);
+end;
+```
+
+**Optimized Code:**
+```al
+procedure ValidateItemForSale(ItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal): Boolean
+var
+    Item: Record Item;
+    Location: Record Location;
+begin
+    // Fast validation first - fail early on simple checks
+    if Quantity <= 0 then
+        exit(false);
+
+    if not Item.Get(ItemNo) then
+        exit(false);
+
+    // Basic item validation
+    if not IsItemAvailableForSale(Item) then
+        exit(false);
+
+    // Location validation
+    if not IsLocationValidForSale(LocationCode) then
+        exit(false);
+
+    // Expensive operations only after basic validation passes
+    if not HasSufficientInventory(ItemNo, LocationCode, Quantity) then
+        exit(false);
+
+    if not IsInventoryUnreserved(ItemNo, LocationCode) then
+        exit(false);
+
+    if not HasValidPricing(ItemNo) then
+        exit(false);
+
+    exit(true);
+end;
+
+local procedure IsItemAvailableForSale(Item: Record Item): Boolean
+begin
+    exit((Item.Blocked = false) and (Item.Type = Item.Type::Inventory));
+end;
+
+local procedure IsLocationValidForSale(LocationCode: Code[10]): Boolean
+var
+    Location: Record Location;
+begin
+    if not Location.Get(LocationCode) then
+        exit(false);
+
+    exit(Location."Use As In-Transit" = false);
+end;
+
+local procedure HasSufficientInventory(ItemNo: Code[20]; LocationCode: Code[10]; RequiredQty: Decimal): Boolean
+var
+    AvailableInventory: Decimal;
+begin
+    AvailableInventory := CalculateAvailableInventory(ItemNo, LocationCode);
+    exit(AvailableInventory >= RequiredQty);
+end;
+
+local procedure IsInventoryUnreserved(ItemNo: Code[20]; LocationCode: Code[10]): Boolean
+begin
+    exit(not CheckReservationStatus(ItemNo, LocationCode));
+end;
+
+local procedure HasValidPricing(ItemNo: Code[20]): Boolean
+begin
+    exit(CheckSpecialPricing(ItemNo));
+end;
+```
+
+### Example 4: Complex Range and Set Validation
+
+**Problematic Code:**
+```al
+procedure ValidateGLAccountPosting(GLAccountNo: Code[20]; PostingDate: Date; Amount: Decimal): Boolean
+var
+    GLAccount: Record "G/L Account";
+    AccountingPeriod: Record "Accounting Period";
+    GLSetup: Record "General Ledger Setup";
+    UserSetup: Record "User Setup";
+begin
+    GLAccount.Get(GLAccountNo);
+    GLSetup.Get();
+
+    // Overly complex condition mixing different validation concerns
+    if (GLAccount.Blocked = false) and
+       (GLAccount."Direct Posting" = true) and
+       ((GLAccount."Account Type" = GLAccount."Account Type"::Posting) or
+        (GLAccount."Account Type" = GLAccount."Account Type"::"Begin-Total") or
+        (GLAccount."Account Type" = GLAccount."Account Type"::"End-Total")) and
+       (PostingDate <> 0D) and
+       (PostingDate >= GLSetup."Allow Posting From") and
+       (PostingDate <= GLSetup."Allow Posting To") and
+       ((Amount > 0) or (Amount < 0)) and
+       (Amount <> 0) and
+       ((UserSetup.Get(UserId()) and
+         ((UserSetup."Allow Posting From" = 0D) or (PostingDate >= UserSetup."Allow Posting From")) and
+         ((UserSetup."Allow Posting To" = 0D) or (PostingDate <= UserSetup."Allow Posting To"))) or
+        (not UserSetup.Get(UserId()))) then
+        exit(true)
+    else
+        exit(false);
+end;
+```
+
+**Simplified Code:**
+```al
+procedure ValidateGLAccountPosting(GLAccountNo: Code[20]; PostingDate: Date; Amount: Decimal): Boolean
+var
+    GLAccount: Record "G/L Account";
+begin
+    if not GLAccount.Get(GLAccountNo) then
+        exit(false);
+
+    // Separate validation concerns for clarity
+    exit(IsAccountValidForPosting(GLAccount) and
+         IsPostingDateValid(PostingDate) and
+         IsAmountValid(Amount));
+end;
+
+local procedure IsAccountValidForPosting(GLAccount: Record "G/L Account"): Boolean
+begin
+    if GLAccount.Blocked then
+        exit(false);
+
+    if not GLAccount."Direct Posting" then
+        exit(false);
+
+    // Simplified account type check using set inclusion
+    exit(GLAccount."Account Type" in [
+        GLAccount."Account Type"::Posting,
+        GLAccount."Account Type"::"Begin-Total",
+        GLAccount."Account Type"::"End-Total"
+    ]);
+end;
+
+local procedure IsPostingDateValid(PostingDate: Date): Boolean
+begin
+    if PostingDate = 0D then
+        exit(false);
+
+    exit(IsWithinSystemDateRange(PostingDate) and IsWithinUserDateRange(PostingDate));
+end;
+
+local procedure IsWithinSystemDateRange(PostingDate: Date): Boolean
+var
+    GLSetup: Record "General Ledger Setup";
+begin
+    GLSetup.Get();
+    exit((PostingDate >= GLSetup."Allow Posting From") and
+         (PostingDate <= GLSetup."Allow Posting To"));
+end;
+
+local procedure IsWithinUserDateRange(PostingDate: Date): Boolean
+var
+    UserSetup: Record "User Setup";
+begin
+    // If no user setup exists, allow posting (system rules apply)
+    if not UserSetup.Get(UserId()) then
+        exit(true);
+
+    // Check user-specific date restrictions
+    if (UserSetup."Allow Posting From" <> 0D) and (PostingDate < UserSetup."Allow Posting From") then
+        exit(false);
+
+    if (UserSetup."Allow Posting To" <> 0D) and (PostingDate > UserSetup."Allow Posting To") then
+        exit(false);
+
+    exit(true);
+end;
+
+local procedure IsAmountValid(Amount: Decimal): Boolean
+begin
+    // Simplified: amount must be non-zero (positive or negative)
+    exit(Amount <> 0);
+end;
+```
+
+## Performance-Oriented Boolean Optimization
+
+### Example 5: Database Query Optimization Through Boolean Logic
+
+**Problematic Code:**
+```al
+procedure FindEligibleCustomersForPromotion(): List of [Code[20]]
+var
+    Customer: Record Customer;
+    CustomerList: List of [Code[20]];
+    SalesHeader: Record "Sales Header";
+    TotalSales: Decimal;
+    HasRecentOrder: Boolean;
+    IsHighValue: Boolean;
+    IsActiveAccount: Boolean;
+begin
+    // Inefficient: processes all customers regardless of basic criteria
+    if Customer.FindSet() then
+        repeat
+            // Multiple database hits per customer
+            Customer.CalcFields("Sales (LCY)");
+            TotalSales := Customer."Sales (LCY)";
+
+            SalesHeader.SetRange("Sell-to Customer No.", Customer."No.");
+            SalesHeader.SetFilter("Order Date", '>=%1', CalcDate('-6M', Today()));
+            HasRecentOrder := not SalesHeader.IsEmpty();
+
+            IsHighValue := TotalSales > 50000;
+            IsActiveAccount := Customer.Blocked = Customer.Blocked::" ";
+
+            // Complex condition evaluated for every customer
+            if (IsActiveAccount = true) and
+               (IsHighValue = true) and
+               (HasRecentOrder = true) and
+               (Customer."Country/Region Code" = 'US') and
+               (Customer."Customer Posting Group" <> 'CASH') then
+                CustomerList.Add(Customer."No.");
+        until Customer.Next() = 0;
+
+    exit(CustomerList);
+end;
+```
+
+**Optimized Code:**
+```al
+procedure FindEligibleCustomersForPromotion(): List of [Code[20]]
+var
+    Customer: Record Customer;
+    CustomerList: List of [Code[20]];
+begin
+    // Pre-filter customers to reduce dataset
+    SetCustomerFiltersForPromotion(Customer);
+
+    if Customer.FindSet() then
+        repeat
+            if IsCustomerEligibleForPromotion(Customer) then
+                CustomerList.Add(Customer."No.");
+        until Customer.Next() = 0;
+
+    exit(CustomerList);
+end;
+
+local procedure SetCustomerFiltersForPromotion(var Customer: Record Customer)
+begin
+    // Apply filters early to reduce record set
+    Customer.SetRange(Blocked, Customer.Blocked::" ");  // Active accounts only
+    Customer.SetRange("Country/Region Code", 'US');     // US customers only
+    Customer.SetFilter("Customer Posting Group", '<>%1', 'CASH'); // Exclude cash customers
+end;
+
+local procedure IsCustomerEligibleForPromotion(Customer: Record Customer): Boolean
+begin
+    // Short-circuit evaluation: check expensive operations last
+    exit(IsHighValueCustomer(Customer) and HasRecentActivity(Customer));
+end;
+
+local procedure IsHighValueCustomer(Customer: Record Customer): Boolean
+begin
+    Customer.CalcFields("Sales (LCY)");
+    exit(Customer."Sales (LCY)" > 50000);
+end;
+
+local procedure HasRecentActivity(Customer: Record Customer): Boolean
+var
+    SalesHeader: Record "Sales Header";
+begin
+    SalesHeader.SetRange("Sell-to Customer No.", Customer."No.");
+    SalesHeader.SetFilter("Order Date", '>=%1', CalcDate('-6M', Today()));
+    exit(not SalesHeader.IsEmpty());
+end;
+```
+
+## Best Practices for Boolean Expression Simplification
+
+### Readability Improvements
+1. **Extract conditions into well-named boolean variables** for complex expressions
+2. **Use early return patterns** to avoid deeply nested if-else structures
+3. **Group related conditions** into separate validation methods
+4. **Apply De Morgan's laws** to eliminate complex negative conditions
+
+### Performance Optimizations
+1. **Order conditions by evaluation cost** - simple checks first, expensive operations last
+2. **Use short-circuit evaluation** to avoid unnecessary calculations
+3. **Pre-filter datasets** before applying complex boolean logic
+4. **Cache expensive boolean calculations** when used multiple times
+
+### Maintainability Patterns
+1. **Separate concerns** - group related validation logic together
+2. **Use meaningful method names** that clearly indicate validation purpose
+3. **Avoid magic numbers and values** in boolean expressions
+4. **Document complex business logic** with comments explaining the reasoning
+
+### Common Anti-Patterns to Avoid
+1. **Redundant conditions** like `(Amount > 0) or (Amount < 0)` instead of `Amount <> 0`
+2. **Comparing booleans to true/false** like `if (IsValid = true)` instead of `if IsValid`
+3. **Complex negative conditions** that can be simplified with De Morgan's laws
+4. **Mixing different validation concerns** in single boolean expressions
+
+## Related Concepts
+- **Guard Clauses**: Using early returns to simplify validation logic
+- **Specification Pattern**: Encapsulating business rules in reusable boolean expressions
+- **Chain of Responsibility**: Breaking complex validation into sequential checks
+- **Short-Circuit Evaluation**: Leveraging AL's boolean evaluation order for performance

package/embedded-knowledge/domains/roger-reviewer/samples/case-error-handling.md

@@ -0,0 +1,64 @@
+# Case Statement Error Handling - AL Code Samples
+
+## Basic Error Handling Pattern
+
+```al
+procedure ProcessOrderStatus(OrderStatus: Enum "Sales Document Status")
+begin
+    case OrderStatus of
+        OrderStatus::Open:
+            ProcessOpenOrder();
+        OrderStatus::Released:
+            ProcessReleasedOrder();
+        OrderStatus::"Pending Approval":
+            ProcessPendingOrder();
+        else
+            Error('Unsupported order status: %1', OrderStatus);
+    end;
+end;
+```
+
+## Safe Processing with TryFunction
+
+```al
+[TryFunction]
+procedure ProcessOrderStatusSafe(OrderStatus: Enum "Sales Document Status"): Boolean
+begin
+    case OrderStatus of
+        OrderStatus::Open:
+            exit(TryProcessOpenOrder());
+        OrderStatus::Released:
+            exit(TryProcessReleasedOrder());
+        else
+            exit(false);
+    end;
+end;
+```
+
+## Exception Recovery Pattern
+
+```al
+procedure ProcessWithRecovery(ProcessingType: Text; MaxAttempts: Integer)
+var
+    Attempts: Integer;
+    Success: Boolean;
+begin
+    repeat
+        Attempts += 1;
+        case ProcessingType of
+            'STANDARD':
+                Success := TryStandardProcessing();
+            'FALLBACK':
+                Success := TryFallbackProcessing();
+            else
+                Success := false;
+        end;
+        
+        if not Success and (Attempts < MaxAttempts) then
+            Sleep(1000);
+    until Success or (Attempts >= MaxAttempts);
+    
+    if not Success then
+        Error('Failed after %1 attempts', MaxAttempts);
+end;
+```

package/embedded-knowledge/domains/roger-reviewer/samples/compound-statement-readability.md

@@ -0,0 +1,107 @@
+# AL Compound Statement Readability Examples
+
+## Basic Conditional Enhancement
+
+### Before: Single Statement
+```al
+if CustomerExists then
+    CreateOrder();
+```
+
+### After: Compound Statement
+```al
+if CustomerExists then begin
+    CreateOrder();
+end;
+```
+
+## Complex Conditional Logic
+
+### Nested Conditions with Clear Structure
+```al
+if ValidateCustomer(CustomerNo) then begin
+    if CheckCreditLimit(CustomerNo, OrderAmount) then begin
+        CreateSalesOrder(CustomerNo, OrderAmount);
+        UpdateCustomerBalance(CustomerNo, OrderAmount);
+        SendOrderConfirmation(CustomerNo);
+    end else begin
+        LogCreditLimitExceeded(CustomerNo, OrderAmount);
+        NotifyCustomerService(CustomerNo);
+    end;
+end else begin
+    LogInvalidCustomer(CustomerNo);
+    RaiseCustomerValidationError(CustomerNo);
+end;
+```
+
+## Loop Structure Clarification
+
+### For Loop with Single Statement
+```al
+for i := 1 to ItemCount do begin
+    ProcessItem(i);
+end;
+```
+
+### While Loop with Multiple Operations
+```al
+while not ItemLedgerEntry.IsEmpty() do begin
+    ItemLedgerEntry.CalcFields("Remaining Quantity");
+    if ItemLedgerEntry."Remaining Quantity" > 0 then begin
+        UpdateInventoryPosition(ItemLedgerEntry);
+        LogInventoryTransaction(ItemLedgerEntry);
+    end;
+    ItemLedgerEntry.Next();
+end;
+```
+
+## Error Handling Organization
+
+### Exception Handling with Compound Blocks
+```al
+if not ValidateOrderData(SalesHeader) then begin
+    LogValidationError(SalesHeader."No.");
+    NotifyUser('Order validation failed');
+    exit(false);
+end;
+
+try
+    ProcessSalesOrder(SalesHeader);
+except
+    on E: Exception do begin
+        LogException(E.Message, SalesHeader."No.");
+        RollbackTransaction();
+        RaiseOrderProcessingError(E.Message);
+    end;
+end;
+```
+
+## Case Statement Structure
+
+### Clear Case Branch Organization
+```al
+case DocumentType of
+    DocumentType::Quote:
+        begin
+            ValidateQuoteData();
+            UpdateQuoteStatus();
+        end;
+    DocumentType::Order:
+        begin
+            ValidateOrderData();
+            ReserveInventory();
+            UpdateOrderStatus();
+        end;
+    DocumentType::Invoice:
+        begin
+            ValidateInvoiceData();
+            PostToGeneralLedger();
+            UpdateInvoiceStatus();
+        end;
+    else
+        begin
+            LogUnsupportedDocumentType(DocumentType);
+            Error('Unsupported document type: %1', DocumentType);
+        end;
+end;
+```