Quick Start

mkdir zakat_calculator
cd zakat_calculator
dart create . --template console

// lib/zakat_calculator.dart

/// Represents different types of wealth subject to Zakat
enum WealthType {
  // => Enumeration of wealth categories
  cash,           // => Cash holdings
  gold,           // => Gold assets
  silver,         // => Silver assets
  investments,    // => Investment portfolios
  business,       // => Business inventory/assets
}

/// Represents a single wealth item
class WealthItem {
  // => Models individual wealth component
  final WealthType type;        // => Category of wealth
  final String description;     // => Human-readable description
  final double amount;          // => Monetary value

  WealthItem({
    // => Constructor with named parameters
    required this.type,         // => Must provide type
    required this.description,  // => Must provide description
    required this.amount,       // => Must provide amount
  });

  @override
  String toString() {
    // => Custom string representation
    return '$description: Rp${_formatCurrency(amount)}';
    // => Returns formatted string
    // => Example: "Savings: Rp1,000,000"
  }

  static String _formatCurrency(double amount) {
    // => Helper method for formatting
    // => Static: belongs to class, not instance
    return amount.toStringAsFixed(0)
        // => Converts to string with 0 decimal places
        .replaceAllMapped(
          // => Applies pattern matching
          RegExp(r'(\d{1,3})(?=(\d{3})+(?!\d))'),
          // => Regex: finds groups of 3 digits
          (Match match) => '${match[1]},',
          // => Adds comma after each group
        );
    // => Returns formatted currency string
  }
}

/// Represents the complete Zakat calculation
class ZakatCalculation {
  // => Models calculation results
  final double totalWealth;     // => Sum of all wealth
  final double nisabThreshold;  // => Minimum threshold
  final double zakatAmount;     // => Calculated Zakat due
  final bool isZakatDue;        // => Whether Zakat is obligatory

  ZakatCalculation({
    // => Constructor with named parameters
    required this.totalWealth,
    required this.nisabThreshold,
    required this.zakatAmount,
    required this.isZakatDue,
  });

  @override
  String toString() {
    // => String representation of calculation
    var buffer = StringBuffer();  // => Efficient string builder
                                  // => Better than concatenation

    buffer.writeln('=== Zakat Calculation Results ===');
    // => Adds line with newline
    buffer.writeln('Total Wealth: Rp${_formatCurrency(totalWealth)}');
    buffer.writeln('Nisab Threshold: Rp${_formatCurrency(nisabThreshold)}');
    buffer.writeln();  // => Empty line for spacing

    if (isZakatDue) {
      // => Zakat is obligatory
      buffer.writeln('✓ Zakat is DUE');
      buffer.writeln('Zakat Amount: Rp${_formatCurrency(zakatAmount)}');
      // => Shows amount due
    } else {
      // => Wealth below threshold
      buffer.writeln('✗ Zakat is NOT due (below nisab threshold)');
    }

    return buffer.toString();  // => Converts buffer to string
  }

  static String _formatCurrency(double amount) {
    // => Same formatting logic as WealthItem
    return amount.toStringAsFixed(0).replaceAllMapped(
          RegExp(r'(\d{1,3})(?=(\d{3})+(?!\d))'),
          (Match match) => '${match[1]},',
        );
  }
}

/// Service class for Zakat calculations
class ZakatCalculatorService {
  // => Business logic for calculations
  static const double ZAKAT_RATE = 0.025;  // => 2.5% rate (constant)
  static const double GOLD_NISAB_GRAMS = 85.0;  // => 85 grams threshold

  final double goldPricePerGram;  // => Current market price
  final List<WealthItem> wealthItems = [];  // => Collection of wealth
                                            // => Initialized as empty list

  ZakatCalculatorService({
    // => Constructor
    required this.goldPricePerGram,  // => Must provide gold price
  });

  void addWealthItem(WealthItem item) {
    // => Adds wealth to portfolio
    wealthItems.add(item);  // => Appends to list
  }

  double get totalWealth {
    // => Getter computed property
    // => Calculates total on access
    return wealthItems.fold<double>(
      // => fold: reduce collection to single value
      0.0,  // => Initial accumulator value
      (sum, item) => sum + item.amount,
      // => Accumulator function
      // => sum: current total
      // => item: current wealth item
      // => Returns: new total
    );
  }

  double get nisabThreshold {
    // => Computed nisab threshold
    return GOLD_NISAB_GRAMS * goldPricePerGram;
    // => 85 grams × current price per gram
  }

  ZakatCalculation calculate() {
    // => Performs Zakat calculation
    final wealth = totalWealth;  // => Get current total wealth
    final nisab = nisabThreshold;  // => Get current threshold
    final isZakatDue = wealth >= nisab;  // => Compare wealth to nisab
                                         // => true if Zakat obligatory

    final zakatAmount = isZakatDue
        ? wealth * ZAKAT_RATE  // => Calculate 2.5% if due
        : 0.0;                 // => 0 if not due

    return ZakatCalculation(
      // => Create result object
      totalWealth: wealth,
      nisabThreshold: nisab,
      zakatAmount: zakatAmount,
      isZakatDue: isZakatDue,
    );
  }

  void reset() {
    // => Clear all wealth items
    wealthItems.clear();  // => Removes all elements from list
  }
}

// bin/zakat_calculator.dart

import 'dart:io';  // => Import I/O library for console
                   // => Provides stdin, stdout, exit

import 'package:zakat_calculator/zakat_calculator.dart';
// => Import our library
// => Package import uses project name

void main() {
  // => Entry point of program
  print('=== Zakat Calculator ===\n');

  // Get gold price
  final goldPrice = promptForGoldPrice();
  // => Gets current gold price from user
  // => final: variable can't be reassigned

  // Create calculator service
  final calculator = ZakatCalculatorService(
    goldPricePerGram: goldPrice,
  );
  // => Instantiates calculator with gold price

  // Collect wealth items
  print('\nEnter your wealth items (enter empty description to finish):');
  collectWealthItems(calculator);
  // => Prompts user for wealth items
  // => Adds items to calculator

  // Calculate and display results
  final result = calculator.calculate();
  // => Performs calculation
  // => Returns ZakatCalculation object

  print('\n${result}');
  // => Prints formatted results
  // => Calls toString() on result
}

double promptForGoldPrice() {
  // => Gets gold price from user input
  while (true) {
    // => Loop until valid input
    stdout.write('Enter current gold price per gram (IDR): ');
    // => Prompt without newline
    final input = stdin.readLineSync();
    // => Read line from console
    // => Returns String? (nullable)

    if (input == null || input.isEmpty) {
      // => Check for null or empty input
      print('Please enter a valid price.');
      continue;  // => Skip to next iteration
    }

    final price = double.tryParse(input);
    // => Attempt to parse as double
    // => Returns null if parsing fails

    if (price == null || price <= 0) {
      // => Validate parsed value
      print('Please enter a positive number.');
      continue;  // => Try again
    }

    return price;  // => Valid price entered, return it
  }
}

void collectWealthItems(ZakatCalculatorService calculator) {
  // => Collects wealth items from user
  // => calculator: service to add items to

  while (true) {
    // => Loop until user finishes
    stdout.write('\nDescription (or press Enter to finish): ');
    final description = stdin.readLineSync();
    // => Read wealth item description

    if (description == null || description.isEmpty) {
      // => Empty input signals completion
      break;  // => Exit loop
    }

    final type = promptForWealthType();
    // => Get wealth category from user
    final amount = promptForAmount();
    // => Get monetary amount from user

    final item = WealthItem(
      // => Create wealth item object
      type: type,
      description: description,
      amount: amount,
    );

    calculator.addWealthItem(item);
    // => Add item to calculator
    print('Added: ${item}');
    // => Confirm addition to user
  }
}

WealthType promptForWealthType() {
  // => Gets wealth type from user
  print('\nSelect wealth type:');
  print('1. Cash');
  print('2. Gold');
  print('3. Silver');
  print('4. Investments');
  print('5. Business');

  while (true) {
    // => Loop until valid selection
    stdout.write('Enter number (1-5): ');
    final input = stdin.readLineSync();
    // => Read user choice

    final choice = int.tryParse(input ?? '');
    // => Parse as integer
    // => Uses empty string if input is null

    switch (choice) {
      // => Match choice to wealth type
      case 1:
        return WealthType.cash;
      case 2:
        return WealthType.gold;
      case 3:
        return WealthType.silver;
      case 4:
        return WealthType.investments;
      case 5:
        return WealthType.business;
      default:
        // => Invalid choice
        print('Invalid selection. Please enter 1-5.');
        // => Continues loop
    }
  }
}

double promptForAmount() {
  // => Gets amount from user
  while (true) {
    // => Loop until valid input
    stdout.write('Amount (IDR): ');
    final input = stdin.readLineSync();

    if (input == null || input.isEmpty) {
      print('Please enter an amount.');
      continue;
    }

    final amount = double.tryParse(input);
    // => Attempt to parse as double

    if (amount == null || amount < 0) {
      // => Validate parsed amount
      print('Please enter a non-negative number.');
      continue;
    }

    return amount;  // => Valid amount entered
  }
}

dart run

final double goldPricePerGram;  // => final: assigned once, immutable
                                // => double: decimal number type

const double ZAKAT_RATE = 0.025;  // => const: compile-time constant
                                  // => Always 2.5%, never changes

var amount = 1000.0;  // => var: type inferred from value
                      // => Inferred as double

double promptForGoldPrice() {
  // => Function declaration
  // => double: return type
  // => (): no parameters
  // Function body
  return price;  // => Returns double value
}

void collectWealthItems(ZakatCalculatorService calculator) {
  // => void: returns no value
  // => calculator: parameter of type ZakatCalculatorService
  // Function body
}

class WealthItem {
  // => Class definition
  final WealthType type;  // => Instance field
  final String description;
  final double amount;

  WealthItem({
    required this.type,  // => Named constructor parameter
                         // => required: must be provided
                         // => this.type: assigns to field directly
    required this.description,
    required this.amount,
  });
}

// Creating instance:
final item = WealthItem(
  type: WealthType.cash,  // => Named argument
  description: 'Savings',
  amount: 50000000.0,
);

String? input = stdin.readLineSync();
// => String?: nullable type (can be null)
// => String: non-nullable (never null)

if (input == null || input.isEmpty) {
  // => Must check null before using
  return;
}

// After null check, input is promoted to non-nullable
print(input.toUpperCase());  // => Safe: null checked above

final List<WealthItem> wealthItems = [];
// => List<WealthItem>: list of WealthItem objects
// => []: empty list literal

wealthItems.add(item);  // => Adds item to end
wealthItems.clear();    // => Removes all items

final Map<String, double> prices = {
  // => Map<String, double>: string keys, double values
  'gold': 1000000.0,    // => Key: 'gold', Value: 1000000.0
  'silver': 15000.0,
};

prices['gold'];  // => Access value by key: 1000000.0
prices['platinum'] = 2000000.0;  // => Add new entry

var name = 'Ahmad';
var age = 30;

// String interpolation
print('Name: $name, Age: $age');
// => Output: Name: Ahmad, Age: 30

// Expression interpolation
print('Next year: ${age + 1}');
// => Output: Next year: 31

// StringBuffer for efficiency
var buffer = StringBuffer();
buffer.writeln('Line 1');
buffer.writeln('Line 2');
print(buffer.toString());
// => Output: Line 1
//            Line 2

final amount = double.tryParse(input);
// => tryParse: returns null if parsing fails
// => Safe alternative to parse (which throws exception)

if (amount == null) {
  // => Check for parsing failure
  print('Invalid input');
  return;
}

// amount is non-null here
print('Valid amount: $amount');

import 'package:test/test.dart';  // => Testing framework
import 'package:zakat_calculator/zakat_calculator.dart';

void main() {
  // => Test suite entry point
  group('ZakatCalculatorService', () {
    // => Group related tests
    test('calculates Zakat correctly when due', () {
      // => Individual test case
      final calculator = ZakatCalculatorService(
        goldPricePerGram: 1000000.0,
      );

      calculator.addWealthItem(WealthItem(
        type: WealthType.cash,
        description: 'Savings',
        amount: 100000000.0,  // 100 million IDR
      ));

      final result = calculator.calculate();
      // => Perform calculation

      expect(result.isZakatDue, isTrue);
      // => Assert Zakat is due
      expect(result.zakatAmount, equals(2500000.0));
      // => Assert amount is 2.5%
      expect(result.totalWealth, equals(100000000.0));
      // => Assert total wealth correct
    });

    test('returns no Zakat when below nisab', () {
      final calculator = ZakatCalculatorService(
        goldPricePerGram: 1000000.0,
      );

      calculator.addWealthItem(WealthItem(
        type: WealthType.cash,
        description: 'Savings',
        amount: 50000000.0,  // 50 million IDR (below nisab)
      ));

      final result = calculator.calculate();

      expect(result.isZakatDue, isFalse);
      // => Assert Zakat not due
      expect(result.zakatAmount, equals(0.0));
      // => Assert amount is zero
    });
  });
}

dart test
# => Runs all tests
# => Output shows pass/fail for each test