English Language Helpers

def join(l, conj='and', im_a_moron=False, separator=','):
    """
    Join lists of words with Oxford comma and proper English grammar.
    
    Args:
        l (list): List of strings to join
        conj (str): Conjunction word to use (default: 'and')
        im_a_moron (bool): Whether to disable Oxford comma (default: False)
        separator (str): Separator character between items (default: ',')
    
    Returns:
        str: Properly formatted English list string
    
    Grammar Rules:
        - Two items: "item1 and item2" (no comma)
        - Three+ items: "item1, item2, and item3" (Oxford comma)
        - im_a_moron=True: "item1, item2 and item3" (no Oxford comma)
    """

from clint.eng import join

# Basic list joining
colors = ['red', 'green', 'blue']
result = join(colors)
# Returns: "red, green, and blue"

# Two items (no comma needed)
pair = ['apple', 'orange']
result = join(pair)
# Returns: "apple and orange"

# Single item
single = ['banana']
result = join(single)
# Returns: "banana"

# Custom conjunction
options = ['save', 'load', 'quit']
result = join(options, conj='or')
# Returns: "save, load, or quit"

# Disable Oxford comma
items = ['Tom', 'Dick', 'Harry']
result = join(items, im_a_moron=True)
# Returns: "Tom, Dick and Harry"

# Custom separator
files = ['file1.txt', 'file2.txt', 'file3.txt']
result = join(files, separator=';')
# Returns: "file1.txt; file2.txt; and file3.txt"

MORON_MODE = False      # Default Oxford comma setting
COMMA = ','             # Default separator character
CONJUNCTION = 'and'     # Default conjunction word
SPACE = ' '             # Space character constant

from clint.eng import join, CONJUNCTION, COMMA

# Using module constants
tasks = ['compile', 'test', 'deploy']

# Standard format
result = join(tasks, conj=CONJUNCTION, separator=COMMA)
# Returns: "compile, test, and deploy"

# Alternative conjunctions
result = join(tasks, conj='then')
# Returns: "compile, then test, then deploy"

from clint.eng import join

def show_help():
    commands = ['start', 'stop', 'restart', 'status']
    options = ['--verbose', '--quiet', '--config']
    
    print(f"Available commands: {join(commands, conj='or')}")
    print(f"Common options: {join(options)}")

# Output:
# Available commands: start, stop, restart, or status
# Common options: --verbose, --quiet, and --config

from clint.eng import join

def validate_required_fields(data, required_fields):
    missing = [field for field in required_fields if field not in data]
    if missing:
        if len(missing) == 1:
            raise ValueError(f"Missing required field: {missing[0]}")
        else:
            raise ValueError(f"Missing required fields: {join(missing)}")

# Usage
try:
    validate_required_fields({'name': 'John'}, ['name', 'email', 'age'])
except ValueError as e:
    print(e)  # "Missing required fields: email and age"

from clint.eng import join

def system_status(services):
    running = [s for s in services if s['status'] == 'running']
    stopped = [s for s in services if s['status'] == 'stopped']
    
    if running:
        names = [s['name'] for s in running]
        print(f"Running services: {join(names)}")
    
    if stopped:
        names = [s['name'] for s in stopped]
        print(f"Stopped services: {join(names, conj='and')}")

# Usage
services = [
    {'name': 'nginx', 'status': 'running'},
    {'name': 'postgresql', 'status': 'running'},
    {'name': 'redis', 'status': 'stopped'}
]
system_status(services)
# Output:
# Running services: nginx and postgresql
# Stopped services: redis

from clint.eng import join

def summarize_config(config):
    enabled_features = [k for k, v in config.items() if v is True]
    disabled_features = [k for k, v in config.items() if v is False]
    
    if enabled_features:
        print(f"Enabled: {join(enabled_features)}")
    
    if disabled_features:
        print(f"Disabled: {join(disabled_features)}")

# Usage
config = {
    'logging': True,
    'caching': True,
    'debugging': False,
    'profiling': False
}
summarize_config(config)
# Output:
# Enabled: logging and caching
# Disabled: debugging and profiling

from clint.eng import join

def format_file_list(files, action='process'):
    if not files:
        return f"No files to {action}"
    
    if action == 'delete':
        return f"Will delete: {join(files)}"
    elif action == 'backup':
        return f"Choose files to backup: {join(files, conj='or')}"
    else:
        return f"Processing: {join(files)}"

# Usage
files = ['document.pdf', 'image.jpg', 'data.csv']
print(format_file_list(files, 'delete'))
# Output: "Will delete: document.pdf, image.jpg, and data.csv"

print(format_file_list(files[:2], 'backup'))
# Output: "Choose files to backup: document.pdf or image.jpg"

from clint.eng import join
from clint.textui import prompt

def select_from_options(options, prompt_text="Choose an option"):
    option_list = join(options, conj='or')
    question = f"{prompt_text} ({option_list}):"
    
    while True:
        choice = prompt.query(question).lower()
        if choice in [opt.lower() for opt in options]:
            return choice
        print(f"Please choose {option_list}")

# Usage
environments = ['development', 'staging', 'production']
env = select_from_options(environments, "Select environment")
# Prompt: "Select environment (development, staging, or production):"

from clint.eng import join

def format_permission_summary(permissions):
    """Format permissions with different conjunctions for different contexts."""
    
    if len(permissions) <= 2:
        return f"Permissions: {join(permissions, conj='and')}"
    else:
        # For longer lists, group by type
        read_perms = [p for p in permissions if 'read' in p.lower()]
        write_perms = [p for p in permissions if 'write' in p.lower()]
        admin_perms = [p for p in permissions if 'admin' in p.lower()]
        
        parts = []
        if read_perms:
            parts.append(f"read ({join(read_perms)})")
        if write_perms:
            parts.append(f"write ({join(write_perms)})")
        if admin_perms:
            parts.append(f"admin ({join(admin_perms)})")
        
        return f"Permissions: {join(parts)}"

# Usage
perms = ['read_users', 'read_posts', 'write_posts', 'admin_settings']
print(format_permission_summary(perms))
# Output: "Permissions: read (read_users and read_posts), write (write_posts), and admin (admin_settings)"