laneful-ruby 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92cd0ae4c28744530a747d496d4b22e65dc92e6f2238739b59e75f7dd36769a7
-  data.tar.gz: 87e2c139cb4e26e60c6209f87b88241a0e4161e19b1ffc2dd9da0f254654843c
+  metadata.gz: 4cebf80375fe3b41ce712f115c4e291c6f7ff0a9ceb4cf90de829422966b970b
+  data.tar.gz: 7fee98bf4a843ffe95123f1c544545760fd4f943651199619b93450e37c7727e
 SHA512:
-  metadata.gz: f8218f49eb9b96cce7b4941fdfe058ef88017c356b0dedc8c18f7bd46cf0398a598255fcbe0a74737d695a0282f0a5e7660a229a94de7406e9694c07b0dcfa72
-  data.tar.gz: 61498ac2d546d3971e6054b5603dbb777dac4b14efb4ac946aa4ac90f89765ffc5d347192b7d5200800ef4dfda2af033d91b1c58d6cdd3704bac9f9c208a199a
+  metadata.gz: 11e4cea266db6d53a73958d9bf4b6a4106c31fe1cb7bcba62f52959444fc9c70d2b2432906bb4c540365b0edbe76af09d4f55a80f84a1f16445595d0f8242cce
+  data.tar.gz: 0f94b21d5267eb709cbada7cca3225f2eb4a6cebdfa694a2d63caec3d2fc7a7bf3f375e564cbedec8632fd08c91b0546a883175a9d591661c759bf562de82270

data/lib/laneful/models.rb

@@ -124,12 +124,13 @@ module Laneful
 
     # Creates an attachment from a hash representation
     def self.from_hash(data)
-      new(data['filename'], data['content_type'], data['content'])
+      filename = data['file_name'] || data['filename']  # Support both field names
+      new(filename, data['content_type'], data['content'])
     end
 
     def to_hash
       {
-        'filename' => filename,
+        'file_name' => filename,
         'content_type' => content_type,
         'content' => content
       }

data/lib/laneful/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Laneful
-  VERSION = '1.0.1'
+  VERSION = '1.1.1'
 end

data/lib/laneful/webhooks.rb

@@ -1,31 +1,116 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'openssl'
+
 module Laneful
-  # Utility class for verifying webhook signatures
+  # Utility class for verifying webhook signatures and processing webhook payloads
   class WebhookVerifier
     ALGORITHM = 'sha256'
+    SIGNATURE_PREFIX = 'sha256='
+    SIGNATURE_HEADER_NAME = 'x-webhook-signature'
+
+    # Valid event types as documented
+    VALID_EVENT_TYPES = %w[
+      delivery open click drop spam_complaint unsubscribe bounce
+    ].freeze
 
-    # Verifies a webhook signature
+    # UUID pattern for lane_id validation
+    UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+    # Verifies a webhook signature with support for sha256= prefix
+    # @param secret [String] The webhook secret
+    # @param payload [String] The webhook payload
+    # @param signature [String] The signature to verify (may include 'sha256=' prefix)
+    # @return [Boolean] true if the signature is valid, false otherwise
     def self.verify_signature(secret, payload, signature)
       return false if secret.nil? || secret.strip.empty?
       return false if payload.nil?
       return false if signature.nil? || signature.strip.empty?
 
+      # Handle sha256= prefix as documented
+      clean_signature = if signature.start_with?(SIGNATURE_PREFIX)
+                          signature[SIGNATURE_PREFIX.length..]
+                        else
+                          signature
+                        end
+
       expected_signature = generate_signature(secret, payload)
-      secure_compare?(expected_signature, signature)
+      secure_compare?(expected_signature, clean_signature)
     rescue StandardError
       false
     end
 
     # Generates a signature for the given payload
-    def self.generate_signature(secret, payload)
+    # @param secret [String] The webhook secret
+    # @param payload [String] The payload to sign
+    # @param include_prefix [Boolean] Whether to include the 'sha256=' prefix
+    # @return [String] The generated signature
+    def self.generate_signature(secret, payload, include_prefix: false)
       digest = OpenSSL::Digest.new(ALGORITHM)
       hmac = OpenSSL::HMAC.new(secret, digest)
       hmac.update(payload)
-      hmac.hexdigest
+      signature = hmac.hexdigest
+      include_prefix ? "#{SIGNATURE_PREFIX}#{signature}" : signature
+    end
+
+    # Parse and validate webhook payload structure
+    # @param payload [String] The raw webhook payload JSON
+    # @return [Hash] Hash containing :is_batch boolean and :events array
+    # @raise [ArgumentError] If payload is invalid JSON or structure
+    def self.parse_webhook_payload(payload)
+      raise ArgumentError, 'Payload cannot be empty' if payload.nil? || payload.strip.empty?
+
+      data = JSON.parse(payload)
+
+      if data.is_a?(Array)
+        # Batch mode: array of events
+        events = data.map { |event| validate_and_parse_event(event) }
+        { is_batch: true, events: events }
+      elsif data.is_a?(Hash) && data.key?('event')
+        # Single event mode
+        event = validate_and_parse_event(data)
+        { is_batch: false, events: [event] }
+      else
+        raise ArgumentError, 'Invalid webhook payload structure'
+      end
+    rescue JSON::ParserError => e
+      raise ArgumentError, "Invalid JSON payload: #{e.message}"
+    end
+
+    # Get the webhook header name as documented
+    # @return [String] The correct header name for webhook signatures
+    def self.signature_header_name
+      SIGNATURE_HEADER_NAME
+    end
+
+    # Extract webhook signature from HTTP headers (supports multiple formats)
+    # @param headers [Hash] HTTP headers hash
+    # @return [String, nil] The webhook signature or nil if not found
+    def self.extract_signature_from_headers(headers)
+      return nil if headers.nil?
+
+      # Try documented header name first
+      signature = headers[SIGNATURE_HEADER_NAME]
+      return signature if signature
+
+      # Try uppercase version
+      upper_header = SIGNATURE_HEADER_NAME.upcase.tr('-', '_')
+      signature = headers[upper_header]
+      return signature if signature
+
+      # Try with HTTP_ prefix (common in Rack environments)
+      server_header = "HTTP_#{upper_header}"
+      signature = headers[server_header]
+      return signature if signature
+
+      nil
     end
 
     # Compares two strings in constant time to prevent timing attacks
+    # @param str_a [String] First string
+    # @param str_b [String] Second string
+    # @return [Boolean] true if strings are equal, false otherwise
     def self.secure_compare?(str_a, str_b)
       return false unless str_a.bytesize == str_b.bytesize
 
@@ -34,5 +119,49 @@ module Laneful
       str_b.each_byte { |byte| res |= byte ^ l.shift }
       res.zero?
     end
+
+    # Validate individual event structure according to documentation
+    # @param event [Hash] The event data
+    # @return [Hash] Parsed event hash
+    # @raise [ArgumentError] If event structure is invalid
+    def self.validate_and_parse_event(event)
+      raise ArgumentError, 'Event must be a hash' unless event.is_a?(Hash)
+
+      # Required fields
+      required_fields = %w[event email lane_id message_id timestamp]
+      required_fields.each do |field|
+        raise ArgumentError, "Missing required field: #{field}" unless event.key?(field)
+      end
+
+      # Validate event type
+      event_type = event['event']
+      raise ArgumentError, "Invalid event type: #{event_type}" unless VALID_EVENT_TYPES.include?(event_type)
+
+      # Validate email format
+      email = event['email']
+      raise ArgumentError, "Invalid email format: #{email}" unless valid_email?(email)
+
+      # Validate timestamp is numeric
+      timestamp = event['timestamp']
+      begin
+        Integer(timestamp)
+      rescue ArgumentError, TypeError
+        raise ArgumentError, 'Invalid timestamp format'
+      end
+
+      # Validate lane_id is a valid UUID format
+      lane_id = event['lane_id']
+      raise ArgumentError, "Invalid lane_id format: #{lane_id}" unless UUID_PATTERN.match?(lane_id)
+
+      # Return event with all fields (required + optional)
+      event
+    end
+
+    # Simple email validation
+    # @param email [String] The email to validate
+    # @return [Boolean] true if email format is valid
+    def self.valid_email?(email)
+      email.is_a?(String) && email.include?('@') && email.include?('.')
+    end
   end
 end

data/lib/laneful.rb

@@ -23,5 +23,5 @@ module Laneful
   DEFAULT_TIMEOUT = 30
 
   # User agent string
-  USER_AGENT = 'laneful-ruby/1.0.0'
+  USER_AGENT = 'laneful-ruby/1.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: laneful-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Laneful Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-05 00:00:00.000000000 Z
+date: 2025-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -46,22 +46,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
-- LICENSE
-- Makefile
-- README.md
-- Rakefile
-- examples/Gemfile
-- examples/README.md
-- examples/simple_example.rb
-- laneful-ruby.gemspec
 - lib/laneful.rb
 - lib/laneful/client.rb
 - lib/laneful/exceptions.rb
 - lib/laneful/models.rb
 - lib/laneful/version.rb
 - lib/laneful/webhooks.rb
-- scripts/publish.sh
 homepage: https://github.com/laneful/laneful-ruby
 licenses:
 - MIT

data/.rubocop.yml

@@ -1,31 +0,0 @@
-AllCops:
-  NewCops: enable
-  TargetRubyVersion: 3.0
-  SuggestExtensions: false
-
-# Disable some strict rules for test files and gemspec
-Metrics/BlockLength:
-  Exclude:
-    - 'spec/**/*'
-    - '*.gemspec'
-
-Metrics/MethodLength:
-  Max: 30
-
-Metrics/ClassLength:
-  Max: 150
-
-Metrics/AbcSize:
-  Max: 80
-
-Metrics/CyclomaticComplexity:
-  Max: 40
-
-Metrics/PerceivedComplexity:
-  Max: 40
-
-Metrics/ParameterLists:
-  Max: 5
-
-Layout/LineLength:
-  Max: 120

data/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Laneful
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/Makefile

@@ -1,49 +0,0 @@
-# Laneful Ruby SDK Makefile
-
-.PHONY: help test lint build publish clean install setup
-
-# Default target
-help:
-	@echo "Available commands:"
-	@echo "  setup    - Install dependencies"
-	@echo "  test     - Run tests"
-	@echo "  lint     - Run code linting"
-	@echo "  build    - Build the gem"
-	@echo "  publish  - Publish to RubyGems (requires RUBYGEMS_API_KEY)"
-	@echo "  install  - Install gem locally"
-	@echo "  clean    - Clean up built gems"
-
-# Install dependencies
-setup:
-	bundle install
-
-# Run tests
-test:
-	bundle exec rspec
-
-# Run linting
-lint:
-	bundle exec rubocop
-
-# Build gem
-build:
-	gem build laneful-ruby.gemspec
-
-# Publish to RubyGems
-publish:
-	@if [ -z "$$GEM_HOST_API_KEY" ]; then \
-		echo "Error: GEM_HOST_API_KEY environment variable is not set"; \
-		echo "Please set your RubyGems API key: export GEM_HOST_API_KEY=your_api_key_here"; \
-		exit 1; \
-	fi
-	./scripts/publish.sh
-
-# Install gem locally
-install:
-	gem build laneful-ruby.gemspec
-	gem install laneful-ruby-*.gem
-
-# Clean up
-clean:
-	rm -f laneful-ruby-*.gem
-

data/README.md

@@ -1,456 +0,0 @@
-# Laneful Ruby SDK
-
-A modern Ruby client library for the Laneful email API with support for sending emails, templates, tracking, and webhooks.
-
-## Requirements
-
-- Ruby 3.0 or higher
-- Bundler (for dependency management)
-
-## Installation
-
-### Using Bundler
-
-Add the following to your `Gemfile`:
-
-```ruby
-gem 'laneful-ruby'
-```
-
-Then run:
-
-```bash
-bundle install
-```
-
-### Manual Installation
-
-```bash
-git clone https://github.com/lanefulhq/laneful-ruby.git
-cd laneful-ruby
-bundle install
-bundle exec rake install
-```
-
-## Quick Start
-
-```ruby
-require 'laneful'
-
-# Create client
-client = Laneful::Client.new(
-  'https://your-endpoint.send.laneful.net',
-  'your-auth-token'
-)
-
-# Create email
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com', 'Your Name'))
-  .to(Laneful::Address.new('recipient@example.com', 'Recipient Name'))
-  .subject('Hello from Laneful Ruby SDK!')
-  .text_content('This is a simple test email.')
-  .build
-
-# Send email
-response = client.send_email(email)
-puts "Email sent successfully!"
-```
-
-## Features
-
-- Send single or multiple emails
-- Plain text and HTML content
-- Email templates with dynamic data
-- File attachments
-- Email tracking (opens, clicks, unsubscribes)
-- Custom headers and reply-to addresses
-- Scheduled sending
-- Webhook signature verification
-- Comprehensive error handling
-- Modern Ruby 3.0+ features
-
-## Examples
-
-### Simple Text Email
-
-```ruby
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com'))
-  .to(Laneful::Address.new('user@example.com'))
-  .subject('Simple Email')
-  .text_content('This is a simple text email.')
-  .build
-
-response = client.send_email(email)
-```
-
-### HTML Email with Tracking
-
-```ruby
-tracking = Laneful::TrackingSettings.new(opens: true, clicks: true, unsubscribes: false)
-
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com'))
-  .to(Laneful::Address.new('user@example.com'))
-  .subject('HTML Email with Tracking')
-  .html_content('<h1>Welcome!</h1><p>This is an <strong>HTML email</strong> with tracking enabled.</p>')
-  .text_content('Welcome! This is an HTML email with tracking enabled.')
-  .tracking(tracking)
-  .build
-
-response = client.send_email(email)
-```
-
-### Template Email
-
-```ruby
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com'))
-  .to(Laneful::Address.new('user@example.com'))
-  .template_id('welcome-template')
-  .template_data({
-    'name' => 'John Doe',
-    'company' => 'Acme Corp'
-  })
-  .build
-
-response = client.send_email(email)
-```
-
-### Email with Attachments
-
-```ruby
-# Create attachment from file
-attachment = Laneful::Attachment.from_file('/path/to/document.pdf')
-
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com'))
-  .to(Laneful::Address.new('user@example.com'))
-  .subject('Document Attached')
-  .text_content('Please find the document attached.')
-  .attachment(attachment)
-  .build
-
-response = client.send_email(email)
-```
-
-### Multiple Recipients
-
-```ruby
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com'))
-  .to(Laneful::Address.new('user1@example.com'))
-  .to(Laneful::Address.new('user2@example.com', 'User Two'))
-  .cc(Laneful::Address.new('cc@example.com'))
-  .bcc(Laneful::Address.new('bcc@example.com'))
-  .subject('Multiple Recipients')
-  .text_content('This email has multiple recipients.')
-  .build
-
-response = client.send_email(email)
-```
-
-### Scheduled Email
-
-```ruby
-# Schedule for 24 hours from now
-send_time = Time.now.to_i + (24 * 60 * 60)
-
-email = Laneful::Email::Builder.new
-  .from(Laneful::Address.new('sender@example.com'))
-  .to(Laneful::Address.new('user@example.com'))
-  .subject('Scheduled Email')
-  .text_content('This email was scheduled.')
-  .send_time(send_time)
-  .build
-
-response = client.send_email(email)
-```
-
-### Multiple Emails
-
-```ruby
-emails = [
-  Laneful::Email::Builder.new
-    .from(Laneful::Address.new('sender@example.com'))
-    .to(Laneful::Address.new('user1@example.com'))
-    .subject('Email 1')
-    .text_content('First email content.')
-    .build,
-  Laneful::Email::Builder.new
-    .from(Laneful::Address.new('sender@example.com'))
-    .to(Laneful::Address.new('user2@example.com'))
-    .subject('Email 2')
-    .text_content('Second email content.')
-    .build
-]
-
-response = client.send_emails(emails)
-```
-
-### Custom Timeout
-
-```ruby
-client = Laneful::Client.new(
-  'https://your-endpoint.send.laneful.net',
-  'your-auth-token',
-  timeout: 60  # 60 second timeout
-)
-```
-
-## Webhook Verification
-
-```ruby
-# In your webhook handler
-payload = request.body.read
-signature = request.headers['X-Laneful-Signature']
-secret = 'your-webhook-secret'
-
-if Laneful::WebhookVerifier.verify_signature(secret, payload, signature)
-  # Process webhook data
-  data = JSON.parse(payload)
-  # Handle webhook event
-else
-  # Invalid signature
-  head :unauthorized
-end
-```
-
-## Error Handling
-
-```ruby
-begin
-  response = client.send_email(email)
-  puts "Email sent successfully"
-rescue Laneful::ValidationException => e
-  puts "Validation error: #{e.message}"
-rescue Laneful::ApiException => e
-  puts "API error: #{e.message}"
-  puts "Status code: #{e.status_code}"
-  puts "Error message: #{e.error_message}"
-rescue Laneful::HttpException => e
-  puts "HTTP error: #{e.message}"
-  puts "Status code: #{e.status_code}"
-rescue StandardError => e
-  puts "Unexpected error: #{e.message}"
-end
-```
-
-## API Reference
-
-### Laneful::Client
-
-#### Constructor
-
-```ruby
-Laneful::Client.new(base_url, auth_token, timeout: 30)
-```
-
-- `base_url` - The base URL of the Laneful API
-- `auth_token` - The authentication token
-- `timeout` - Request timeout in seconds (optional, default: 30)
-
-#### Methods
-
-- `send_email(email)` - Sends a single email
-- `send_emails(emails)` - Sends multiple emails
-
-### Laneful::Email::Builder
-
-#### Required Fields
-
-- `from(address)` - Sender address
-
-#### Optional Fields
-
-- `to(address)` - Recipient addresses
-- `cc(address)` - CC addresses
-- `bcc(address)` - BCC addresses
-- `subject(subject)` - Email subject
-- `text_content(content)` - Plain text content
-- `html_content(content)` - HTML content
-- `template_id(id)` - Template ID
-- `template_data(data)` - Template data
-- `attachment(attachment)` - File attachments
-- `headers(headers)` - Custom headers
-- `reply_to(address)` - Reply-to address
-- `send_time(time)` - Scheduled send time (Unix timestamp)
-- `webhook_data(data)` - Webhook data
-- `tag(tag)` - Email tag
-- `tracking(tracking)` - Tracking settings
-
-### Laneful::Address
-
-```ruby
-Laneful::Address.new(email, name = nil)
-```
-
-- `email` - The email address (required)
-- `name` - The display name (optional)
-
-### Laneful::Attachment
-
-```ruby
-# From file
-Laneful::Attachment.from_file(file_path)
-
-# From raw data
-Laneful::Attachment.new(filename, content_type, content)
-```
-
-### Laneful::TrackingSettings
-
-```ruby
-Laneful::TrackingSettings.new(opens: false, clicks: false, unsubscribes: false)
-```
-
-### Laneful::WebhookVerifier
-
-```ruby
-Laneful::WebhookVerifier.verify_signature(secret, payload, signature)
-```
-
-## Exception Types
-
-- `Laneful::ValidationException` - Thrown when input validation fails
-- `Laneful::ApiException` - Thrown when the API returns an error response
-- `Laneful::HttpException` - Thrown when HTTP communication fails
-- `Laneful::LanefulException` - Base exception class for all SDK exceptions
-
-## Development
-
-### Running Tests
-
-```bash
-bundle exec rspec
-```
-
-### Code Quality
-
-```bash
-bundle exec rubocop
-```
-
-### Documentation
-
-```bash
-bundle exec yard doc
-```
-
-## Publishing to RubyGems
-
-This SDK can be published to RubyGems using a simple, automated workflow.
-
-### Prerequisites
-
-1. **Ruby 3.0+**: Ensure you have Ruby 3.0 or higher installed
-2. **Bundler**: Install bundler if not already installed (`gem install bundler`)
-3. **RubyGems API Key**: Get your API key from [RubyGems.org](https://rubygems.org/settings/edit)
-
-### Setting up your API Key
-
-```bash
-export GEM_HOST_API_KEY=your_api_key_here
-```
-
-### Publishing Methods
-
-#### Method 1: Using the Automated Script (Recommended)
-
-```bash
-./scripts/publish.sh
-```
-
-This script will:
-
-- Check Ruby version compatibility
-- Install dependencies
-- Run all tests
-- Perform code linting
-- Build the gem
-- Publish to RubyGems
-- Clean up built gem files
-
-#### Method 2: Using Make Commands
-
-**Install dependencies:**
-
-```bash
-make setup
-```
-
-**Run tests:**
-
-```bash
-make test
-```
-
-**Run linting:**
-
-```bash
-make lint
-```
-
-**Build the gem:**
-
-```bash
-make build
-```
-
-**Publish to RubyGems:**
-
-```bash
-make publish
-```
-
-#### Method 3: Manual Publishing
-
-**Install dependencies:**
-
-```bash
-bundle install
-```
-
-**Run tests:**
-
-```bash
-bundle exec rspec
-```
-
-**Run linting:**
-
-```bash
-bundle exec rubocop
-```
-
-**Build the gem:**
-
-```bash
-gem build laneful-ruby.gemspec
-```
-
-**Publish to RubyGems:**
-
-```bash
-gem push laneful-ruby-*.gem
-```
-
-### Version Management
-
-Before publishing, make sure to update the version in `lib/laneful/version.rb`:
-
-```ruby
-module Laneful
-  VERSION = "1.0.1".freeze  # Update this version
-end
-```
-
-Follow [Semantic Versioning](https://semver.org/) guidelines:
-
-- **MAJOR** version for incompatible API changes
-- **MINOR** version for backwards-compatible functionality additions
-- **PATCH** version for backwards-compatible bug fixes
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

data/Rakefile

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec

data/examples/Gemfile

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'laneful-ruby'

data/examples/README.md

@@ -1,53 +0,0 @@
-# Laneful Ruby SDK Examples
-
-This directory contains example code demonstrating how to use the Laneful Ruby SDK.
-
-## Quick Start
-
-1. **Install the gem:**
-   ```bash
-   gem install laneful-ruby
-   ```
-
-2. **Or use Bundler:**
-   ```bash
-   cd examples
-   bundle install
-   ```
-
-3. **Configure the example:**
-   Edit `simple_example.rb` and replace the placeholder values:
-   - `base_url`: Your Laneful endpoint URL
-   - `auth_token`: Your authentication token
-   - Email addresses: Replace with your actual email addresses
-
-4. **Run the example:**
-   ```bash
-   ruby simple_example.rb
-   ```
-
-## Example Files
-
-- **`simple_example.rb`**: Demonstrates basic email sending functionality including:
-  - Simple text email
-  - HTML email with tracking
-  - Email with CC recipients
-  - Error handling
-
-## Configuration
-
-Before running the examples, make sure to:
-
-1. **Get your credentials** from your Laneful dashboard
-2. **Update the configuration** in the example files:
-   ```ruby
-   base_url = 'https://your-endpoint.send.laneful.net'
-   auth_token = 'your-auth-token'
-   ```
-3. **Use valid email addresses** for testing
-
-## More Examples
-
-For more comprehensive examples and API documentation, visit:
-- [Laneful Ruby SDK Documentation](https://docs.laneful.com/ruby)
-- [GitHub Repository](https://github.com/laneful/laneful-ruby)

data/examples/simple_example.rb

@@ -1,121 +0,0 @@
-#!/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

@@ -1,38 +0,0 @@
-# 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/scripts/publish.sh

@@ -1,169 +0,0 @@
-#!/bin/bash
-
-# Laneful Ruby SDK Publishing Script
-# This script handles the complete publishing workflow to RubyGems
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Function to print colored output
-print_status() {
-    echo -e "${BLUE}[INFO]${NC} $1"
-}
-
-print_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $1"
-}
-
-print_warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $1"
-}
-
-print_error() {
-    echo -e "${RED}[ERROR]${NC} $1"
-}
-
-# Check if required environment variables are set
-check_environment() {
-    print_status "Checking environment variables..."
-    
-    if [ -z "$GEM_HOST_API_KEY" ]; then
-        print_error "GEM_HOST_API_KEY environment variable is not set"
-        print_status "Please set your RubyGems API key:"
-        print_status "export GEM_HOST_API_KEY=your_api_key_here"
-        exit 1
-    fi
-    
-    print_success "Environment variables are set"
-}
-
-# Check if we're in the right directory
-check_directory() {
-    if [ ! -f "laneful-ruby.gemspec" ]; then
-        print_error "laneful-ruby.gemspec not found. Please run this script from the project root."
-        exit 1
-    fi
-    print_success "Found gemspec file"
-}
-
-# Check Ruby version
-check_ruby_version() {
-    print_status "Checking Ruby version..."
-    ruby_version=$(ruby -v | cut -d' ' -f2)
-    required_version="3.0.0"
-    
-    if [ "$(printf '%s\n' "$required_version" "$ruby_version" | sort -V | head -n1)" = "$required_version" ]; then
-        print_success "Ruby version $ruby_version is compatible"
-    else
-        print_error "Ruby version $ruby_version is not compatible. Required: $required_version or higher"
-        exit 1
-    fi
-}
-
-# Install dependencies
-install_dependencies() {
-    print_status "Installing dependencies..."
-    bundle install
-    if [ $? -eq 0 ]; then
-        print_success "Dependencies installed successfully"
-    else
-        print_error "Failed to install dependencies. Aborting publish."
-        exit 1
-    fi
-}
-
-# Run tests
-run_tests() {
-    print_status "Running tests..."
-    bundle exec rspec
-    if [ $? -eq 0 ]; then
-        print_success "All tests passed"
-    else
-        print_error "Tests failed. Aborting publish."
-        exit 1
-    fi
-}
-
-# Run linting
-run_lint() {
-    print_status "Running linter..."
-    bundle exec rubocop
-    if [ $? -eq 0 ]; then
-        print_success "Linting passed"
-    else
-        print_error "Linting failed. Aborting publish."
-        exit 1
-    fi
-}
-
-# Build the gem
-build_gem() {
-    print_status "Building gem..."
-    gem build laneful-ruby.gemspec
-    if [ $? -eq 0 ]; then
-        print_success "Gem built successfully"
-    else
-        print_error "Gem build failed. Aborting publish."
-        exit 1
-    fi
-}
-
-# Publish to RubyGems
-publish_gem() {
-    print_status "Publishing to RubyGems..."
-    gem push laneful-ruby-*.gem
-    if [ $? -eq 0 ]; then
-        print_success "Gem published successfully to RubyGems!"
-    else
-        print_error "Failed to publish gem to RubyGems."
-        exit 1
-    fi
-}
-
-# Clean up
-cleanup() {
-    print_status "Cleaning up..."
-    rm -f laneful-ruby-*.gem
-    print_success "Cleanup completed"
-}
-
-# Main execution
-main() {
-    print_status "Starting Laneful Ruby SDK publishing process..."
-    
-    check_environment
-    check_directory
-    check_ruby_version
-    install_dependencies
-    
-    # Ask for confirmation
-    echo
-    print_warning "This will publish the gem to RubyGems. Are you sure? (y/N)"
-    read -r response
-    if [[ ! "$response" =~ ^[Yy]$ ]]; then
-        print_status "Publishing cancelled."
-        exit 0
-    fi
-    
-    run_tests
-    run_lint
-    build_gem
-    publish_gem
-    cleanup
-    
-    print_success "Publishing process completed successfully!"
-    print_status "Your gem is now available on RubyGems: https://rubygems.org/gems/laneful-ruby"
-}
-
-# Handle script interruption
-trap cleanup EXIT
-
-# Run main function
-main "$@"
-