RubyGems - laneful-ruby - Versions diffs - 1.0.1 - Mend

laneful-ruby 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

data/examples/simple_example.rb ADDED Viewed

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require 'laneful'
+# Simple example demonstrating basic usage of the Laneful Ruby SDK
+puts '📧 Laneful Ruby SDK - Simple Example'
+puts "====================================\n"
+# Configuration - Replace with your actual credentials
+base_url = 'https://your-endpoint.send.laneful.net'
+auth_token = 'your-auth-token'
+# Email addresses - Replace with your actual addresses
+sender_email = 'sender@yourdomain.com'
+sender_name = 'Your Name'
+recipient_email = 'recipient@example.com'
+recipient_name = 'Recipient Name'
+cc_email = 'cc@example.com'
+cc_name = 'CC Recipient'
+# Create client
+begin
+  client = Laneful::Client.new(base_url, auth_token)
+  puts '✅ Client created successfully'
+rescue Laneful::ValidationException => e
+  puts "❌ Failed to create client: #{e.message}"
+  puts 'Please check your base_url and auth_token configuration.'
+  exit 1
+end
+# Test 1: Send a simple text email
+puts "\n📝 Test 1: Sending Simple Text Email"
+puts '------------------------------------'
+begin
+  email = Laneful::Email::Builder.new
+                                 .from(Laneful::Address.new(sender_email, sender_name))
+                                 .to(Laneful::Address.new(recipient_email, recipient_name))
+                                 .subject('Hello from Laneful Ruby SDK! 🚀')
+                                 .text_content('Hi! This is a test email sent using the Laneful Ruby SDK. ' \
+                                               'The SDK is working perfectly!')
+                                 .tag('ruby-sdk-test')
+                                 .build
+  response = client.send_email(email)
+  puts '✅ Simple email sent successfully!'
+  puts "Response: #{response}"
+rescue Laneful::ValidationException => e
+  puts "❌ Validation error: #{e.message}"
+rescue Laneful::ApiException => e
+  puts "❌ API error: #{e.message} (Status: #{e.status_code})"
+rescue Laneful::HttpException => e
+  puts "❌ HTTP error: #{e.message} (Status: #{e.status_code})"
+end
+# Test 2: Send an HTML email with CC
+puts "\n🎨 Test 2: Sending HTML Email with CC"
+puts '-------------------------------------'
+begin
+  tracking = Laneful::TrackingSettings.new(opens: true, clicks: true, unsubscribes: false)
+  email = Laneful::Email::Builder.new
+                                 .from(Laneful::Address.new(sender_email, sender_name))
+                                 .to(Laneful::Address.new(recipient_email, recipient_name))
+                                 .cc(Laneful::Address.new(cc_email, cc_name))
+                                 .subject('Ruby SDK Test - HTML Email with Tracking 📧')
+                                 .html_content(<<~HTML)
+                                   <!DOCTYPE html>
+                                   <html>
+                                   <head>
+                                       <title>Ruby SDK Test</title>
+                                   </head>
+                                   <body style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
+                                       <h1 style="color: #2c3e50;">🎉 Ruby SDK Test Successful!</h1>
+                                       <p>Hello! This email was sent using the <strong>Laneful Ruby SDK</strong> with modern Ruby features:</p>
+                                       <ul style="background-color: #f8f9fa; padding: 15px; border-radius: 5px;">
+                                           <li>✅ Frozen string literals for immutability</li>
+                                           <li>✅ Keyword arguments for clean APIs</li>
+                                           <li>✅ Safe navigation operator (&.)</li>
+                                           <li>✅ Enhanced exception handling</li>
+                                           <li>✅ Modern Ruby syntax throughout</li>
+                                       </ul>
+                                       <p style="color: #7f8c8d;">This email has tracking enabled for opens and clicks.</p>
+                                       <hr style="border: none; border-top: 1px solid #eee; margin: 20px 0;">
+                                       <p style="font-size: 12px; color: #95a5a6;">
+                                           Sent from: #{sender_email}<br>
+                                           To: #{recipient_email}<br>
+                                           CC: #{cc_email}
+                                       </p>
+                                   </body>
+                                   </html>
+                                 HTML
+                                 .text_content('Ruby SDK Test Successful! Hello! This email was sent using ' \
+                                               'the Laneful Ruby SDK with modern Ruby features including ' \
+                                               'frozen string literals, keyword arguments, safe navigation ' \
+                                               'operator, and enhanced exception handling. This email has ' \
+                                               'tracking enabled for opens and clicks.')
+                                 .tracking(tracking)
+                                 .tag('html-cc-test')
+                                 .build
+  response = client.send_email(email)
+  puts '✅ HTML email with CC sent successfully!'
+  puts "Response: #{response}"
+rescue Laneful::ValidationException => e
+  puts "❌ Validation error: #{e.message}"
+rescue Laneful::ApiException => e
+  puts "❌ API error: #{e.message} (Status: #{e.status_code})"
+rescue Laneful::HttpException => e
+  puts "❌ HTTP error: #{e.message} (Status: #{e.status_code})"
+end
+puts "\n🎉 Tests completed!"
+puts "\n📋 Summary:"
+puts '   • Ruby SDK is working correctly'
+puts '   • Real API endpoint is accessible'
+puts '   • Email building and sending functionality is operational'
+puts '   • Error handling is working properly'
+puts "\n💡 Check your email inboxes for the test emails!"

data/laneful-ruby.gemspec ADDED Viewed

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative 'lib/laneful/version'
+Gem::Specification.new do |spec|
+  spec.name          = 'laneful-ruby'
+  spec.version       = Laneful::VERSION
+  spec.authors       = ['Laneful Team']
+  spec.email         = ['support@laneful.com']
+  spec.summary       = 'Ruby SDK for the Laneful email API'
+  spec.description   = 'A modern Ruby client library for the Laneful email API, ' \
+                       'providing easy integration for email sending, webhooks, and analytics.'
+  spec.homepage      = 'https://github.com/laneful/laneful-ruby'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/laneful/laneful-ruby'
+  spec.metadata['changelog_uri'] = 'https://github.com/laneful/laneful-ruby/blob/main/CHANGELOG.md'
+  spec.metadata['documentation_uri'] = 'https://docs.laneful.com/ruby'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  # Dependencies
+  spec.add_dependency 'httparty', '~> 0.21'
+  spec.add_dependency 'json', '~> 2.6'
+end

data/lib/laneful/client.rb ADDED Viewed

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+module Laneful
+  # Main client for communicating with the Laneful email API
+  class Client
+    include HTTParty
+    # Default timeout in seconds
+    DEFAULT_TIMEOUT = 30
+    attr_reader :base_url, :auth_token, :timeout
+    def initialize(base_url, auth_token, timeout: DEFAULT_TIMEOUT)
+      @base_url = base_url&.strip
+      @auth_token = auth_token&.strip
+      @timeout = timeout
+      validate_configuration!
+      # Configure HTTParty
+      self.class.base_uri @base_url
+      self.class.default_timeout @timeout
+      self.class.headers default_headers
+    end
+    # Sends a single email
+    def send_email(email)
+      send_emails([email])
+    end
+    # Sends multiple emails
+    def send_emails(emails)
+      validate_emails!(emails)
+      request_data = { 'emails' => emails.map(&:to_hash) }
+      response = self.class.post("/#{API_VERSION}/email/send", body: request_data.to_json)
+      handle_response(response)
+    end
+    private
+    def validate_configuration!
+      raise ValidationException, 'Base URL cannot be empty' if base_url.nil? || base_url.empty?
+      raise ValidationException, 'Auth token cannot be empty' if auth_token.nil? || auth_token.empty?
+      # Basic URL validation
+      return if base_url.match?(%r{^https?://})
+      raise ValidationException, 'Base URL must be a valid HTTP/HTTPS URL'
+    end
+    def validate_emails!(emails)
+      raise ValidationException, 'Emails list cannot be empty' if emails.nil? || emails.empty?
+      emails.each do |email|
+        raise ValidationException, 'All emails must be Email instances' unless email.is_a?(Email)
+      end
+    end
+    def default_headers
+      {
+        'Authorization' => "Bearer #{auth_token}",
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json',
+        'User-Agent' => USER_AGENT
+      }
+    end
+    def handle_response(response)
+      case response.code
+      when 200, 201, 202
+        parse_success_response(response)
+      when 404
+        raise HttpException.new(
+          "API endpoint not found (404). Check your base URL. Requested: #{response.request.last_uri}",
+          response.code
+        )
+      else
+        handle_error_response(response)
+      end
+    rescue JSON::ParserError => e
+      error_message = "Failed to decode JSON response: #{e.message}. " \
+                      "Response body: #{truncate_response_body(response.body)}. " \
+                      "URL: #{response.request.last_uri}"
+      raise HttpException.new(error_message, response.code, e)
+    end
+    def parse_success_response(response)
+      return {} if response.body.nil? || response.body.strip.empty?
+      JSON.parse(response.body)
+    end
+    def handle_error_response(response)
+      error_data = parse_error_response(response)
+      error_message = error_data['error'] || 'Unknown API error'
+      details = error_data['details'] || ''
+      full_error = details.empty? ? error_message : "#{error_message} - #{details}"
+      raise ApiException.new(
+        "API request failed to #{response.request.last_uri}",
+        response.code,
+        full_error
+      )
+    end
+    def parse_error_response(response)
+      return {} if response.body.nil? || response.body.strip.empty?
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      { 'error' => 'Invalid JSON response', 'details' => truncate_response_body(response.body) }
+    end
+    def truncate_response_body(body, max_length: 500)
+      return body if body.nil? || body.length <= max_length
+      "#{body[0, max_length]}..."
+    end
+  end
+end

data/lib/laneful/exceptions.rb ADDED Viewed

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Laneful
+  # Base exception class for all Laneful SDK exceptions
+  class LanefulException < StandardError
+    def initialize(message = nil, cause = nil)
+      super(message)
+      @cause = cause
+    end
+    attr_reader :cause
+  end
+  # Exception thrown when input validation fails
+  class ValidationException < LanefulException
+    def initialize(message = nil, cause = nil)
+      super
+    end
+  end
+  # Exception thrown when the API returns an error response
+  class ApiException < LanefulException
+    attr_reader :status_code, :error_message
+    def initialize(message = nil, status_code = nil, error_message = nil, cause: nil)
+      super(message, cause)
+      @status_code = status_code
+      @error_message = error_message
+    end
+  end
+  # Exception thrown when HTTP communication fails
+  class HttpException < LanefulException
+    attr_reader :status_code
+    def initialize(message = nil, status_code = nil, cause = nil)
+      super(message, cause)
+      @status_code = status_code
+    end
+  end
+end