input_py

input_py is a simple Rust library that provides Python-like input functionality for reading user input from the terminal.

Features

Python-like syntax: Familiar input() function similar to Python
Robust error handling: Proper error types instead of panics
Default values: Support for default values when no input is provided
Configurable trimming: Control whitespace handling behavior
Builder pattern: Flexible Input builder for combining options
Rich documentation: Comprehensive examples and documentation
Well tested: Extensive test suite with 70+ tests

Installation

Add this to your Cargo.toml:

[dependencies]
input_py = "2.0.0"

Quick Start

use input_py::input;

fn main() {
    match input("Enter your name") {
        Ok(name) => println!("Hello, {}!", name),
        Err(e) => eprintln!("Error: {}", e),
    }
}

Terminal output:

Enter your name: Alice
Hello, Alice!

API Reference

`input(comment: &str)`

Basic input function that prompts the user and returns the trimmed input.

use input_py::input;

// Basic usage
let name = input("What's your name")?;
println!("Hello, {}!", name);

// Empty prompt
let data = input("")?;  // No prompt displayed

`input_with_default(comment: &str, default: &str)`

Input with a default value that's used when the user enters nothing.

use input_py::input_with_default;

// With default value
let port = input_with_default("Enter port", "8080")?;
println!("Using port: {}", port);

// User sees: "Enter port [8080]:"
// Pressing Enter uses "8080"

`input_trim(comment: &str, trim_whitespace: bool)`

Input with configurable whitespace trimming behavior.

use input_py::input_trim;

// Preserve whitespace
let raw_text = input_trim("Enter text", false)?;
println!("Raw: '{}'", raw_text);

// Trim whitespace (default behavior)
let clean_text = input_trim("Enter text", true)?;
println!("Clean: '{}'", clean_text);

`Input` Builder (new in v2.0.0)

A fluent builder API for combining options like default values, trimming, and prompt visibility.

use input_py::Input;

// Default value + no trimming (not possible with convenience functions alone)
let port = Input::new("Enter port")
    .default("8080")
    .trim(false)
    .read()?;
println!("Port: '{}'", port);

// Hide prompt
let secret = Input::new("Password")
    .show_prompt(false)
    .read()?;

Error Handling

All functions return Result<String, InputError> for robust error handling:

use input_py::{input, InputError};

match input("Enter something") {
    Ok(value) => {
        if value.is_empty() {
            println!("Nothing entered!");
        } else {
            println!("You entered: {}", value);
        }
    }
    Err(InputError::WriteError(e)) => {
        eprintln!("Failed to write to stdout: {}", e);
    }
    Err(InputError::FlushError(e)) => {
        eprintln!("Failed to flush stdout: {}", e);
    }
    Err(InputError::ReadError(e)) => {
        eprintln!("Failed to read from stdin: {}", e);
    }
}

Complete Example

use input_py::{input, input_with_default, input_trim, Input};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== User Registration ===");

    // Required field
    let name = input("Full name")?;
    if name.is_empty() {
        eprintln!("Name is required!");
        return Ok(());
    }

    // Optional field with default
    let age = input_with_default("Age", "18")?;

    // Preserve formatting for addresses
    let address = input_trim("Address (with spacing)", false)?;

    // Builder: default + no trimming
    let city = Input::new("City")
        .default("Tokyo")
        .trim(false)
        .read()?;

    println!("\n--- Registration Complete ---");
    println!("Name: {}", name);
    println!("Age: {}", age);
    println!("Address: '{}'", address);
    println!("City: '{}'", city);

    Ok(())
}

Testing

Run the test suite:

cargo test

The library includes comprehensive tests covering:

Normal input scenarios
Error conditions (WriteError, FlushError, ReadError)
Internal logic verification
Edge cases and special characters
Builder pattern combinations
Japanese input support

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Changelog

v2.0.0

Breaking Changes:

process_input() now returns String instead of Result<String, InputError>
Added InputError::WriteError variant (existing match on InputError may need updating)

New Features:

Added Input builder pattern for combining options (default + trim + show_prompt)
InputError now implements source() for proper error chaining

Bug Fixes:

Fixed StdoutWriter::write_str silently ignoring write errors
Fixed write errors being incorrectly reported as FlushError
Fixed process_input ignoring default_value when trim_whitespace=false

Improvements:

Added WriteError variant to InputError for proper error categorization
Removed unused PROMPT_WITH_DEFAULT_SUFFIX constant
Added Cargo.toml metadata (repository, keywords, categories, rust-version)
Added MSRV testing (Rust 1.70.0) and security audit to CI
Expanded test suite to 70+ tests

v1.0.3

Fixed cargo fmt and clippy CI errors

v1.0.2

Updated version for crates.io publish workflow

v1.0.1

Added GitHub Actions CI and crates.io auto-publish workflow
Split tests into categorized files
Separated config file and added I/O testable abstractions

v1.0.0

Stable release - Ready for production use
Added input_with_default() function for default value support
Added input_trim() function for configurable whitespace handling
Improved error handling with custom InputError type (breaking change)
Enhanced documentation with comprehensive examples and API reference
Added extensive test suite with full coverage

v0.2.1

Basic input functionality similar to Python's input()

input_py 2.0.0