Poodle Ruby SDK

gem 'poodle-ruby'

require 'poodle'

# Initialize the client
client = Poodle::Client.new(api_key: 'your_api_key')

# Send an email
response = client.send(
  from: 'sender@example.com',
  to: 'recipient@example.com',
  subject: 'Hello from Poodle!',
  html: '<h1>Hello World!</h1><p>This email was sent using Poodle.</p>'
)

if response.success?
  puts "Email sent successfully!"
else
  puts "Failed to send email: #{response.message}"
end

# 1. Pass directly to client
client = Poodle::Client.new(api_key: 'your_api_key')

# 2. Use environment variable
ENV['POODLE_API_KEY'] = 'your_api_key'
client = Poodle::Client.new

# 3. Use configuration object
config = Poodle::Configuration.new(
  api_key: 'your_api_key',
  timeout: 30,
  debug: true
)
client = Poodle::Client.new(config)

# HTML email
response = client.send_html(
  from: 'newsletter@example.com',
  to: 'subscriber@example.com',
  subject: 'Weekly Newsletter',
  html: '<h1>Newsletter</h1><p>Your weekly update...</p>'
)

# Plain text email
response = client.send_text(
  from: 'notifications@example.com',
  to: 'user@example.com',
  subject: 'Account Update',
  text: 'Your account has been updated successfully.'
)

# Multipart email (HTML + Text)
response = client.send(
  from: 'support@example.com',
  to: 'customer@example.com',
  subject: 'Welcome!',
  html: '<h1>Welcome!</h1><p>Thanks for joining us.</p>',
  text: 'Welcome! Thanks for joining us.'
)

# Create an Email object for reusability and validation
email = Poodle::Email.new(
  from: 'sender@example.com',
  to: 'recipient@example.com',
  subject: 'Important Update',
  html: '<h1>Update</h1><p>Please read this important update.</p>',
  text: 'Update: Please read this important update.'
)

# Check email properties
puts "Multipart email: #{email.multipart?}"
puts "Content size: #{email.content_size} bytes"

# Send the email
response = client.send_email(email)

# Send emails with both HTML and text content for maximum compatibility
response = client.send(
  from: 'newsletter@example.com',
  to: 'subscriber@example.com',
  subject: 'Weekly Newsletter',
  html: '<h1>Newsletter</h1><p>This week\'s updates...</p>',
  text: 'Newsletter\n\nThis week\'s updates...'
)

gem 'poodle-ruby'

# config/initializers/poodle.rb
Poodle::Rails.configure do |config|
  config.api_key = Rails.application.credentials.poodle_api_key
  config.debug = Rails.env.development?
end

class NotificationController < ApplicationController
  def send_welcome_email
    response = Poodle::Rails.client.send(
      from: "welcome@example.com",
      to: params[:email],
      subject: "Welcome!",
      html: render_to_string("welcome_email")
    )

    if response.success?
      render json: { status: "sent" }
    else
      render json: { error: response.message }, status: :unprocessable_entity
    end
  end
end

# spec/spec_helper.rb or spec/rails_helper.rb
require 'poodle'

RSpec.configure do |config|
  config.include Poodle::TestHelpers

  config.before(:each) do
    Poodle.test_mode!
  end

  config.after(:each) do
    Poodle.clear_deliveries
  end
end

it "sends welcome email" do
  expect {
    UserMailer.send_welcome(user)
  }.to change { Poodle.deliveries.count }.by(1)

  email = Poodle.last_delivery
  expect(email[:to]).to eq(user.email)
  expect(email[:subject]).to include("Welcome")
  expect(email[:html]).to include(user.name)
end

it "sends notification emails" do
  service.send_notifications

  assert_email_sent(3)
  assert_email_sent_to("admin@example.com")
  assert_email_sent_with_subject("Alert")
end

begin
  response = client.send(email_data)
  puts "Email sent!" if response.success?
rescue Poodle::ValidationError => e
  puts "Validation failed: #{e.message}"
  e.errors.each do |field, messages|
    puts "#{field}: #{messages.join(', ')}"
  end
rescue Poodle::AuthenticationError => e
  puts "Authentication failed: #{e.message}"
rescue Poodle::RateLimitError => e
  puts "Rate limited. Retry after: #{e.retry_after} seconds"
rescue Poodle::PaymentError => e
  puts "Payment required: #{e.message}"
  puts "Upgrade at: #{e.upgrade_url}"
rescue Poodle::ForbiddenError => e
  puts "Access forbidden: #{e.message}"
rescue Poodle::NetworkError => e
  puts "Network error: #{e.message}"
rescue Poodle::ServerError => e
  puts "Server error: #{e.message}"
rescue Poodle::Error => e
  puts "Poodle error: #{e.message}"
end

def send_with_retry(client, email_data, max_retries: 3)
  retries = 0

  begin
    client.send(email_data)
  rescue Poodle::RateLimitError => e
    if retries < max_retries && e.retry_after
      retries += 1
      sleep(e.retry_after)
      retry
    else
      raise
    end
  rescue Poodle::NetworkError, Poodle::ServerError => e
    if retries < max_retries
      retries += 1
      sleep(2 ** retries) # Exponential backoff
      retry
    else
      raise
    end
  end
end