peasytext

Async Rust client for the PeasyText API -- text case conversion, slug generation, word counting, and encoding utilities with tools for camelCase, snake_case, kebab-case, PascalCase, and more. Built with reqwest, serde, and tokio.

Built from PeasyText, a comprehensive text processing toolkit offering free online tools for case conversion, slug generation, word counting, and text analysis. The glossary covers text concepts from character encodings to Unicode normalization, while guides explain text processing strategies and encoding best practices.

Try the interactive tools at peasytext.com -- Text Counter, Case Converter, Slug Generator, and more.

Table of Contents

• Install
• Quick Start
• What You Can Do
  • Text Processing Tools
  • Browse Text Reference Content
  • Search and Discovery
• API Client
  • Available Methods
• Learn More About Text Processing
• Also Available
• Peasy Developer Tools
• License

Install

[dependencies]
peasytext = "0.2.0"
tokio = { version = "1", features = ["full"] }

Or via cargo:

cargo add peasytext

Quick Start

use peasytext::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // List available text tools
    let tools = client.list_tools(&Default::default()).await?;
    for tool in &tools.results {
        println!("{}: {}", tool.name, tool.description);
    }

    Ok(())
}

What You Can Do

Text Processing Tools

Text transformation is fundamental to software development -- from generating URL-safe slugs for blog posts to converting variable names between camelCase and snake_case during code generation. Case conversion tools handle the mechanical work of transforming text between naming conventions used across programming languages (camelCase in JavaScript, snake_case in Python, kebab-case in CSS). Word counting and character analysis help content authors meet length requirements for SEO titles, meta descriptions, and social media posts.

use peasytext::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // Fetch the case converter tool details
    let tool = client.get_tool("text-case-converter").await?;
    println!("Tool: {}", tool.name);           // Case converter tool
    println!("Category: {}", tool.category);   // Text processing category

    // List supported text formats
    let formats = client.list_formats(&Default::default()).await?;
    for fmt in &formats.results {
        println!(".{} -- {} ({})", fmt.extension, fmt.name, fmt.mime_type);
    }

    // List available format conversions from plain text
    let conversions = client.list_conversions(&peasytext::ListConversionsOptions {
        source: Some("txt".into()),
        ..Default::default()
    }).await?;
    println!("Found {} conversion paths from text", conversions.results.len());

    Ok(())
}

Learn more: Text Counter · Case Converter · Text Encoding Guide

Browse Text Reference Content

The text processing glossary explains key concepts from basic character encodings to advanced Unicode normalization forms. Understanding the difference between ASCII and UTF-8, how byte order marks (BOM) affect file parsing, and when to use URL encoding versus Base64 helps developers handle text data correctly across platforms and programming languages.

// Browse text processing glossary terms
let glossary = client.list_glossary(&peasytext::ListOptions {
    search: Some("slugify".into()),
    ..Default::default()
}).await?;
for term in &glossary.results {
    println!("{}: {}", term.term, term.definition); // Text processing concept definition
}

// Read in-depth guides on text encoding and conversion
let guides = client.list_guides(&peasytext::ListGuidesOptions {
    category: Some("text".into()),
    ..Default::default()
}).await?;
for guide in &guides.results {
    println!("{} ({})", guide.title, guide.audience_level); // Guide title and difficulty
}

Learn more: Slug Glossary · ASCII Glossary · Regex Cheat Sheet

Search and Discovery

The unified search endpoint queries across all text tools, glossary terms, guides, and supported formats simultaneously. This is useful for building text editor plugins, documentation search, or CLI tools that need to discover text processing capabilities.

// Search across all text tools, glossary, and guides
let results = client.search("case", Some(20)).await?;
println!("Found {} tools, {} glossary terms",
    results.results.tools.len(),
    results.results.glossary.len()); // Cross-content text processing search results

Learn more: BOM Glossary · Slug Generator · All Text Guides

API Client

The client wraps the PeasyText REST API with strongly-typed Rust structs using serde deserialization.

use peasytext::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    // Or with a custom base URL:
    // let client = Client::with_base_url("https://custom.example.com");

    // List tools with filters
    let opts = peasytext::ListOptions {
        page: Some(1),
        limit: Some(10),
        search: Some("case".into()),
        ..Default::default()
    };
    let tools = client.list_tools(&opts).await?;

    // Get a specific tool
    let tool = client.get_tool("text-case").await?;
    println!("{}: {}", tool.name, tool.description);

    // Search across all content
    let results = client.search("case", Some(20)).await?;
    println!("Found {} tools", results.results.tools.len());

    // Browse the glossary
    let glossary = client.list_glossary(&peasytext::ListOptions {
        search: Some("slugify".into()),
        ..Default::default()
    }).await?;
    for term in &glossary.results {
        println!("{}: {}", term.term, term.definition);
    }

    // Discover guides
    let guides = client.list_guides(&peasytext::ListGuidesOptions {
        category: Some("text".into()),
        ..Default::default()
    }).await?;
    for guide in &guides.results {
        println!("{} ({})", guide.title, guide.audience_level);
    }

    // List format conversions
    let conversions = client.list_conversions(&peasytext::ListConversionsOptions {
        source: Some("txt".into()),
        ..Default::default()
    }).await?;

    Ok(())
}

Available Methods

Full API documentation at peasytext.com/developers/. OpenAPI 3.1.0 spec: peasytext.com/api/openapi.json.

Learn More About Text Processing

• Tools: Text Counter · Case Converter · Slug Generator · All Tools
• Guides: Text Encoding Guide · Regex Cheat Sheet · All Guides
• Glossary: Slug · ASCII · BOM · All Terms
• Formats: TXT · CSV · All Formats
• API: REST API Docs · OpenAPI Spec

Also Available

Peasy Developer Tools

Part of the Peasy Tools open-source developer ecosystem.

License

MIT