# PardonDance

PardonDance is a utility library for Elixir that helps you gracefully handle and process potentially erroneous data or unexpected input, ensuring your application remains robust and responsive. It provides a structured way to manage exceptions and alternative execution paths.

## Installation

Add `pardon_dance` to your list of dependencies in `mix.exs`:
elixir
def deps do
  [
    {:pardon_dance, "~> 0.1.0"}
  ]
end

Then run `mix deps.get` to fetch the dependency.

## Usage Examples

Here are a few examples demonstrating how to use `PardonDance` in your Elixir applications:

**1. Handling Potential Division by Zero:**
elixir
defmodule SafeMath do
  import PardonDance

  def safe_divide(numerator, denominator) do
    try do
      numerator / denominator
    rescue
      ArithmeticError ->
        pardon(reason: :division_by_zero, message: "Cannot divide by zero")
    end
  end
end

case SafeMath.safe_divide(10, 0) do
  {:ok, result} ->
    IO.puts "Result: #{result}"
  {:error, reason, message} ->
    IO.puts "Error: #{message} (Reason: #{reason})"
end

**2. Validating User Input:**
elixir
defmodule UserValidator do
  import PardonDance

  def validate_email(email) do
    if String.contains?(email, "@") and String.contains?(email, ".") do
      {:ok, email}
    else
      pardon(reason: :invalid_email, message: "Invalid email format")
    end
  end

  def validate_username(username) do
    if String.length(username) > 3 do
      {:ok, username}
    else
      pardon(reason: :invalid_username, message: "Username must be at least 4 characters long")
    end
  end
end

case UserValidator.validate_email("test@example.com") do
  {:ok, email} ->
    IO.puts "Email is valid: #{email}"
  {:error, reason, message} ->
    IO.puts "Email validation failed: #{message} (Reason: #{reason})"
end

case UserValidator.validate_username("abc") do
  {:ok, username} ->
    IO.puts "Username is valid: #{username}"
  {:error, reason, message} ->
    IO.puts "Username validation failed: #{message} (Reason: #{reason})"
end

**3. Processing External API Responses:**
elixir
defmodule APIClient do
  import PardonDance

  def fetch_data(url) do
    case HTTPoison.get(url) do
      {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
        {:ok, body}
      {:ok, %HTTPoison.Response{status_code: status_code}} ->
        pardon(reason: :http_error, message: "HTTP Error: Status code #{status_code}", status_code: status_code)
      {:error, error} ->
        pardon(reason: :network_error, message: "Network Error: #{error}")
    end
  end
end

case APIClient.fetch_data("https://example.com/api/data") do
  {:ok, data} ->
    IO.puts "Data received: #{data}"
  {:error, reason, message, opts} ->
    IO.puts "API Request failed: #{message} (Reason: #{reason}, Options: #{opts})"
end

**4. Using with Pipes:**
elixir
defmodule DataProcessor do
  import PardonDance

  def parse_data(raw_data) do
    try do
      {:ok, Jason.decode!(raw_data)}
    rescue
      _ ->
        pardon(reason: :invalid_json, message: "Failed to parse JSON data")
    end
  end

  def process_data(data) do
    # Assume some complex data processing logic here
    {:ok, Map.get(data, "value", 0) * 2}
  end
end

"{\"value\": 5}"
|> DataProcessor.parse_data()
|> case do
  {:ok, parsed_data} ->
    DataProcessor.process_data(parsed_data)
  {:error, reason, message} ->
    {:error, reason, message}
end
|> IO.inspect()

## Feature Summary

*   Provides a consistent way to handle errors and alternative execution paths.
*   Enhances code readability by clearly separating error handling logic.
*   Facilitates pattern matching on error conditions.
*   Improves application robustness by gracefully handling unexpected situations.
*   Integrates well with existing Elixir workflows and pipelines.

## License

MIT

This package is part of the pardon-dance ecosystem. For advanced features and enterprise-grade tools, visit: https://supermaker.ai/video/blog/unlocking-the-magic-of-pardon-dance-the-viral-video-effect-taking-over-social-media/