vibe-sort 0.2.0 → 0.3.1

data/docs/api_reference.md

@@ -6,30 +6,40 @@ The main public interface for the VibeSort gem.
 
 ### Class Methods
 
-#### `new(api_key:, temperature: 0.0)`
+#### `new(api_key:, temperature: 0.0, provider: :openai, model: nil)`
 
 Creates a new VibeSort client instance.
 
 **Parameters:**
 
-- `api_key` (String, required): Your OpenAI API key
+- `api_key` (String, required): API key for the selected provider
 - `temperature` (Float, optional): Model temperature setting (default: 0.0)
   - Range: 0.0 to 2.0
   - Lower values (0.0-0.3): More deterministic and consistent
   - Higher values (0.7-2.0): More random and creative
+  - Ignored by providers whose current models do not accept it (Anthropic)
+- `provider` (Symbol or String, optional): LLM provider (default: `:openai`)
+  - Supported: `:openai`, `:anthropic`, `:gemini`, `:groq`, `:spacexai`
+- `model` (String, optional): Model ID override (default: the provider's default model)
 
 **Returns:** `VibeSort::Client` instance
 
 **Raises:**
 
-- `ArgumentError`: If api_key is nil or empty
+- `ArgumentError`: If api_key is nil or empty, or the provider is unknown
 
 **Example:**
 
 ```ruby
-# Basic initialization
+# Basic initialization (OpenAI, default provider)
 client = VibeSort::Client.new(api_key: ENV['OPENAI_API_KEY'])
 
+# Anthropic Claude
+client = VibeSort::Client.new(provider: :anthropic, api_key: ENV['ANTHROPIC_API_KEY'])
+
+# Google Gemini with a custom model
+client = VibeSort::Client.new(provider: :gemini, api_key: ENV['GEMINI_API_KEY'], model: 'gemini-2.5-pro')
+
 # With custom temperature
 client = VibeSort::Client.new(
   api_key: ENV['OPENAI_API_KEY'],
@@ -41,7 +51,7 @@ client = VibeSort::Client.new(
 
 #### `sort(array)`
 
-Sorts an array of numbers and/or strings using OpenAI's API.
+Sorts an array of numbers and/or strings using the configured provider's API.
 
 **Parameters:**
 
@@ -100,25 +110,28 @@ Configuration object for VibeSort. Usually not used directly by end users.
 
 ### Class Methods
 
-#### `new(api_key:, temperature: 0.0)`
+#### `new(api_key:, temperature: 0.0, provider: :openai, model: nil)`
 
 Creates a new configuration object.
 
 **Parameters:**
 
-- `api_key` (String, required): OpenAI API key
+- `api_key` (String, required): API key for the selected provider
 - `temperature` (Float, optional): Model temperature (default: 0.0)
+- `provider` (Symbol or String, optional): `:openai` (default), `:anthropic`, `:gemini`, `:groq`, or `:spacexai`
+- `model` (String, optional): Model ID override (nil uses the provider's default)
 
 **Raises:**
 
-- `ArgumentError`: If api_key is nil or empty
+- `ArgumentError`: If api_key is nil or empty, or the provider is unknown
 
 **Example:**
 
 ```ruby
 config = VibeSort::Configuration.new(
   api_key: "sk-...",
-  temperature: 0.0
+  provider: :anthropic,
+  model: "claude-haiku-4-5"
 )
 ```
 
@@ -136,11 +149,23 @@ Returns the configured temperature setting (read-only).
 
 **Returns:** Float
 
+#### `provider`
+
+Returns the configured provider (read-only).
+
+**Returns:** Symbol
+
+#### `model`
+
+Returns the configured model override, or nil when using the provider default (read-only).
+
+**Returns:** String or nil
+
 ---
 
 ## VibeSort::Sorter
 
-Internal class that handles API communication. Not intended for direct use.
+Internal class that dispatches the sorting operation to the configured provider adapter. Not intended for direct use.
 
 ### Class Methods
 
@@ -156,7 +181,7 @@ Creates a new sorter instance.
 
 #### `perform(array)`
 
-Performs the sorting operation via OpenAI API.
+Performs the sorting operation via the configured provider's API.
 
 **Parameters:**
 
@@ -170,17 +195,30 @@ Performs the sorting operation via OpenAI API.
 
 ### Constants
 
-#### `OPENAI_API_URL`
+#### `PROVIDER_CLASSES`
+
+Maps provider symbols to adapter classes.
+
+**Value:** `{ openai:, anthropic:, gemini:, groq:, spacexai: }`
+
+---
 
-The OpenAI API endpoint URL.
+## VibeSort::Providers
 
-**Value:** `"https://api.openai.com/v1/chat/completions"`
+Internal provider adapters. `Providers::Base` holds the shared prompt, Faraday HTTP plumbing, and response validation; each subclass maps one provider's request/response wire format.
 
-#### `DEFAULT_MODEL`
+| Adapter | Endpoint | `DEFAULT_MODEL` |
+|---|---|---|
+| `Providers::OpenAI` | `https://api.openai.com/v1/chat/completions` | `gpt-4o-mini` |
+| `Providers::Anthropic` | `https://api.anthropic.com/v1/messages` | `claude-opus-4-8` |
+| `Providers::Gemini` | `https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent` | `gemini-2.5-flash` |
+| `Providers::Groq` | `https://api.groq.com/openai/v1/chat/completions` | `llama-3.3-70b-versatile` |
+| `Providers::SpaceXAI` | `https://api.x.ai/v1/chat/completions` | `grok-4` |
 
-The default GPT model used for sorting.
+Notes:
 
-**Value:** `"gpt-3.5-turbo-1106"`
+- The Anthropic adapter uses structured outputs (JSON schema) and does not send `temperature` (rejected by current Claude models)
+- The Groq and SpaceXAI adapters subclass `Providers::OpenAI` (OpenAI-compatible APIs)
 
 ---
 
@@ -269,11 +307,13 @@ All sorting operations return a consistent hash structure:
 
 ### API Errors
 
+The `{Provider}` prefix names the configured provider (OpenAI, Anthropic, Gemini, Groq, or SpaceXAI):
+
 | Error Message Pattern | Cause | Solution |
 |----------------------|-------|----------|
-| "OpenAI API error: Invalid API key" | Invalid or missing API key | Check API key |
-| "OpenAI API error: Rate limit exceeded" | Too many requests | Wait and retry |
-| "OpenAI API error: HTTP {status}" | HTTP error | Check API status |
+| "{Provider} API error: Invalid API key" | Invalid or missing API key | Check API key |
+| "{Provider} API error: Rate limit exceeded" | Too many requests | Wait and retry |
+| "{Provider} API error: HTTP {status}" | HTTP error | Check API status |
 
 ### Response Parsing Errors
 
@@ -412,14 +452,14 @@ results = threads.map(&:value)
 
 ## Environment Variables
 
-### OPENAI_API_KEY
-
-Your OpenAI API key. Required for all operations.
-
-**Setup:**
+Set the API key for whichever provider you use:
 
 ```bash
-export OPENAI_API_KEY='sk-your-key-here'
+export OPENAI_API_KEY='sk-your-key-here'      # provider: :openai (default)
+export ANTHROPIC_API_KEY='your-key-here'      # provider: :anthropic
+export GEMINI_API_KEY='your-key-here'         # provider: :gemini
+export GROQ_API_KEY='your-key-here'           # provider: :groq
+export XAI_API_KEY='your-key-here'            # provider: :spacexai
 ```
 
 **Usage:**
@@ -432,9 +472,9 @@ client = VibeSort::Client.new(api_key: ENV['OPENAI_API_KEY'])
 
 ## Version
 
-Current version: `0.1.0`
+Current version: `0.3.0`
 
 ```ruby
 VibeSort::VERSION
-# => "0.1.0"
+# => "0.3.0"
 ```

data/docs/architecture.md

@@ -20,24 +20,36 @@ VibeSort follows a layered architecture with clear separation of concerns:
                   ▼
 ┌─────────────────────────────────────────┐
 │    VibeSort::Configuration              │
+│  - Provider selection                   │
 │  - API key management                   │
+│  - Model override                       │
 │  - Temperature settings                 │
 └─────────────────┬───────────────────────┘
                   │
                   ▼
 ┌─────────────────────────────────────────┐
-│      VibeSort::Sorter                   │
+│      VibeSort::Sorter (dispatcher)      │
+│  - Picks the provider adapter           │
+└─────────────────┬───────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────┐
+│   VibeSort::Providers::Base             │
+│  - Shared prompt                        │
 │  - HTTP client (Faraday)                │
-│  - Request building                     │
-│  - Response parsing                     │
-│  - Validation                           │
+│  - Response parsing & validation        │
+├─────────────────────────────────────────┤
+│  OpenAI │ Anthropic │ Gemini │          │
+│  Groq   │ SpaceXAI                      │
+│  (request/response wire formats)        │
 └─────────────────┬───────────────────────┘
                   │
                   ▼
 ┌─────────────────────────────────────────┐
-│      OpenAI API                         │
-│  https://api.openai.com/v1/chat/       │
-│  completions                            │
+│      Provider API (HTTPS)               │
+│  api.openai.com │ api.anthropic.com     │
+│  generativelanguage.googleapis.com      │
+│  api.groq.com   │ api.x.ai              │
 └─────────────────────────────────────────┘
 ```
 
@@ -55,7 +67,7 @@ VibeSort follows a layered architecture with clear separation of concerns:
 - Return standardized response hashes
 
 **Key Methods**:
-- `initialize(api_key:, temperature: 0.0)`: Creates client with configuration
+- `initialize(api_key:, temperature: 0.0, provider: :openai, model: nil)`: Creates client with configuration
 - `sort(array)`: Sorts array and returns result hash
 
 **Return Format**:
@@ -72,41 +84,46 @@ VibeSort follows a layered architecture with clear separation of concerns:
 **Purpose**: Encapsulates configuration settings.
 
 **Responsibilities**:
-- Store API key securely
-- Store temperature setting
-- Validate API key presence
+- Store provider selection and API key
+- Store model override and temperature setting
+- Validate API key presence and provider name
 
 **Key Methods**:
-- `initialize(api_key:, temperature:)`: Creates configuration
-- Raises `ArgumentError` if API key is nil or empty
+- `initialize(api_key:, temperature: 0.0, provider: :openai, model: nil)`: Creates configuration
+- Raises `ArgumentError` if API key is nil/empty or provider is unknown
 
 **Attributes**:
-- `api_key`: OpenAI API key (String)
-- `temperature`: Model temperature (Float, 0.0-2.0)
+- `api_key`: Provider API key (String)
+- `provider`: `:openai`, `:anthropic`, `:gemini`, `:groq`, or `:spacexai` (Symbol)
+- `model`: Model ID override, or nil for the provider default (String or nil)
+- `temperature`: Model temperature (Float, 0.0-2.0; not sent to Anthropic)
 
 ### VibeSort::Sorter
 
-**Purpose**: Handles communication with OpenAI API.
-
-**Responsibilities**:
-- Build HTTP connection with Faraday
-- Construct API request payload
-- Send POST request to OpenAI
-- Parse and validate JSON responses
-- Extract sorted array from response
-- Raise `ApiError` on failures
+**Purpose**: Dispatches the sort to the configured provider adapter.
 
 **Key Methods**:
 - `initialize(config)`: Creates sorter with configuration
-- `perform(array)`: Executes sort via API
-- `build_payload(array)`: Private - constructs request
-- `handle_response(response)`: Private - processes response
-- `parse_sorted_array(response)`: Private - extracts result
-- `validate_sorted_array!(array)`: Private - validates output
+- `perform(array)`: Looks up the adapter in `PROVIDER_CLASSES` and delegates
 
-**Constants**:
-- `OPENAI_API_URL`: API endpoint
-- `DEFAULT_MODEL`: "gpt-3.5-turbo-1106" (supports JSON mode)
+### VibeSort::Providers
+
+**Purpose**: One adapter per LLM provider, all sharing a common base.
+
+**`Providers::Base` responsibilities**:
+- Hold the shared sorting prompt
+- Build the HTTP connection with Faraday
+- Parse and validate JSON responses (shared across providers)
+- Raise `ApiError` on failures
+
+**Adapter hooks** (implemented per provider): `provider_name`, `endpoint`, `headers`, `build_payload`, `extract_content`
+
+**Adapters and default models**:
+- `Providers::OpenAI`: Chat Completions, `gpt-4o-mini`
+- `Providers::Anthropic`: Messages API with structured outputs (JSON schema), `claude-opus-4-8`
+- `Providers::Gemini`: generateContent with JSON response mode, `gemini-2.5-flash`
+- `Providers::Groq`: OpenAI-compatible (subclasses `Providers::OpenAI`), `llama-3.3-70b-versatile`
+- `Providers::SpaceXAI`: OpenAI-compatible (subclasses `Providers::OpenAI`), `grok-4`
 
 ### VibeSort::ApiError
 
@@ -132,12 +149,12 @@ VibeSort follows a layered architecture with clear separation of concerns:
 
 3. **Client creates Sorter**
    - Passes Configuration object
-   - Sorter initializes Faraday connection
+   - Sorter picks the provider adapter, which initializes a Faraday connection
 
-4. **Sorter builds request payload**
+4. **Adapter builds the provider-specific request payload** (OpenAI example)
    ```json
    {
-     "model": "gpt-3.5-turbo-1106",
+     "model": "gpt-4o-mini",
      "temperature": 0.0,
      "response_format": { "type": "json_object" },
      "messages": [
@@ -153,16 +170,16 @@ VibeSort follows a layered architecture with clear separation of concerns:
    }
    ```
 
-5. **Sorter sends POST request**
-   - URL: `https://api.openai.com/v1/chat/completions`
-   - Headers: Authorization (Bearer token), Content-Type
+5. **Adapter sends POST request**
+   - URL: the adapter's endpoint (e.g. `https://api.openai.com/v1/chat/completions`)
+   - Headers: provider auth (Bearer token, `x-api-key`, or `x-goog-api-key`), Content-Type
    - Body: JSON payload
 
-6. **OpenAI processes request**
+6. **Provider processes request**
    - Model analyzes the array
    - Returns JSON with sorted array
 
-7. **Sorter parses response**
+7. **Adapter parses response** (OpenAI example)
    ```json
    {
      "choices": [{
@@ -227,8 +244,7 @@ VibeSort follows a layered architecture with clear separation of concerns:
 ## Dependencies
 
 ### Runtime
-- **faraday** (~> 2.0): HTTP client library
-- **faraday-json** (~> 1.0): JSON middleware for Faraday
+- **faraday** (~> 2.0): HTTP client library, the only runtime dependency; all providers are called over plain HTTPS
 
 ### Development
 - **rspec** (~> 3.0): Testing framework
@@ -236,8 +252,11 @@ VibeSort follows a layered architecture with clear separation of concerns:
 
 ## Design Decisions
 
-### Why JSON Mode?
-OpenAI's JSON mode (`response_format: { type: "json_object" }`) ensures the model always returns valid JSON, making parsing more reliable.
+### Why JSON Mode / Structured Outputs?
+Each adapter uses the strongest JSON guarantee its provider offers: OpenAI-compatible providers use JSON mode (`response_format: { type: "json_object" }`), Anthropic uses structured outputs with a JSON schema, and Gemini uses `responseMimeType: "application/json"`. This makes parsing reliable across providers.
+
+### Why Raw HTTP Instead of Provider SDKs?
+Three simple JSON POSTs don't justify three SDK dependencies. Keeping everything on Faraday keeps the gem lightweight and the adapters symmetric.
 
 ### Why Temperature 0.0 by Default?
 Lower temperature (0.0) produces deterministic, consistent results. Sorting should be predictable, not creative!
@@ -312,8 +331,7 @@ Potential improvements for future versions:
 
 1. **Batch Sorting**: Sort multiple arrays in one API call
 2. **Caching**: Cache results for identical inputs
-3. **Custom Models**: Allow users to specify different GPT models
-4. **Retry Logic**: Automatic retry on transient failures
+3. **Retry Logic**: Automatic retry on transient failures
 5. **Async Support**: Non-blocking API calls with callbacks
 6. **Metrics**: Track API usage, costs, and performance
 7. **Different Sort Orders**: Support descending order

data/docs/development.md

@@ -521,8 +521,8 @@ Document all public methods:
 # @return [Hash] Result hash with :success, :sorted_array, :error keys
 #
 # @example
-#   client.sort([5, 2, 8])
-#   # => { success: true, sorted_array: [2, 5, 8] }
+# client.sort([5, 2, 8])
+# # => { success: true, sorted_array: [2, 5, 8] }
 def sort(array)
   # ...
 end
@@ -563,4 +563,4 @@ Before submitting a PR:
 - Read the documentation
 - Ask in the community
 
-Happy coding! 🚀
+Happy coding! 

data/docs/v0.2.0_UPDATE.md

@@ -6,23 +6,23 @@ VibeSort has been updated to **version 0.2.0** with support for sorting arrays c
 
 ---
 
-## 🎯 What Changed
+## What Changed
 
 ### Core Functionality
 
 #### Before (v0.1.0)
-- ✅ Sort arrays of numbers (integers and floats)
-- ❌ Strings not supported
-- ❌ Mixed-type arrays rejected
+-  Sort arrays of numbers (integers and floats)
+-  Strings not supported
+-  Mixed-type arrays rejected
 
 #### After (v0.2.0)
-- ✅ Sort arrays of numbers (integers and floats)
-- ✅ Sort arrays of strings (case-sensitive)
-- ✅ Sort mixed-type arrays (numbers + strings)
+-  Sort arrays of numbers (integers and floats)
+-  Sort arrays of strings (case-sensitive)
+-  Sort mixed-type arrays (numbers + strings)
 
 ---
 
-## 📝 Technical Changes
+## Technical Changes
 
 ### 1. Input Validation (`VibeSort::Client`)
 
@@ -114,7 +114,7 @@ end
 
 ---
 
-## 🚀 New Usage Examples
+## New Usage Examples
 
 ### Sorting Strings
 
@@ -141,24 +141,24 @@ puts result[:sorted_array]
 
 ---
 
-## 📋 Sorting Rules
+## Sorting Rules
 
 The AI follows these standard sorting conventions:
 
 1. **Numbers Only**: Ascending numerical order
-   - `[5, 2, 8, 1]` → `[1, 2, 5, 8]`
+   - `[5, 2, 8, 1]`  `[1, 2, 5, 8]`
 
 2. **Strings Only**: Ascending alphabetical order (case-sensitive)
-   - `["banana", "Apple", "cherry"]` → `["Apple", "banana", "cherry"]`
+   - `["banana", "Apple", "cherry"]`  `["Apple", "banana", "cherry"]`
    - Capital letters come before lowercase in ASCII ordering
 
 3. **Mixed Types**: Numbers first, then strings
-   - `[42, "hello", 8, "world"]` → `[8, 42, "hello", "world"]`
+   - `[42, "hello", 8, "world"]`  `[8, 42, "hello", "world"]`
    - Each group is sorted within itself
 
 ---
 
-## 📚 Documentation Updates
+## Documentation Updates
 
 ### Updated Files
 
@@ -185,7 +185,7 @@ The AI follows these standard sorting conventions:
 
 ---
 
-## ✅ Backward Compatibility
+## Backward Compatibility
 
 **Good News:** This update is **fully backward compatible**!
 
@@ -203,7 +203,7 @@ result = client.sort([5, 2, 8, 1, 9])
 
 ---
 
-## 🧪 Testing Recommendations
+## Testing Recommendations
 
 When upgrading to v0.2.0, test these scenarios:
 
@@ -237,7 +237,7 @@ client.sort([1, { key: "value" }]) # Contains hash
 
 ---
 
-## 🔍 Implementation Notes
+## Implementation Notes
 
 ### Why These Changes?
 
@@ -263,27 +263,27 @@ The OpenAI GPT model (gpt-3.5-turbo-1106) handles mixed-type sorting intelligent
 
 ---
 
-## 🎨 Architecture Remains Clean
+## Architecture Remains Clean
 
 The core architecture is unchanged:
 
 ```
 User Application
-      ↓
+      
 VibeSort::Client (validates input)
-      ↓
+      
 VibeSort::Configuration (stores settings)
-      ↓
+      
 VibeSort::Sorter (communicates with OpenAI)
-      ↓
+      
 OpenAI API (processes request)
-      ↓
+      
 Sorted Array (returned to user)
 ```
 
 ---
 
-## 📦 Upgrade Instructions
+## Upgrade Instructions
 
 ### Using Bundler
 
@@ -307,7 +307,7 @@ gem install vibe-sort -v 0.2.0
 
 ---
 
-## 🐛 Known Limitations
+## Known Limitations
 
 Same limitations as v0.1.0:
 
@@ -326,7 +326,7 @@ Same limitations as v0.1.0:
 
 ---
 
-## 🔮 Future Enhancements
+## Future Enhancements
 
 Potential features for future versions:
 
@@ -348,27 +348,27 @@ Potential features for future versions:
 
 ---
 
-## 📞 Support
+## Support
 
-- 🐛 [Report Issues](https://github.com/chayut/vibe-sort/issues)
-- 💡 [Feature Requests](https://github.com/chayut/vibe-sort/issues/new?labels=enhancement)
-- 📖 [Documentation](https://github.com/chayut/vibe-sort/tree/main/docs)
+-  [Report Issues](https://github.com/chayut/vibe-sort/issues)
+-  [Feature Requests](https://github.com/chayut/vibe-sort/issues/new?labels=enhancement)
+-  [Documentation](https://github.com/chayut/vibe-sort/tree/main/docs)
 
 ---
 
-## ✨ Summary
+## Summary
 
 Version 0.2.0 expands VibeSort's capabilities while maintaining:
 
-- ✅ Same clean API
-- ✅ Same architecture
-- ✅ Full backward compatibility
-- ✅ Same performance characteristics
-- ✅ Comprehensive documentation
+-  Same clean API
+-  Same architecture
+-  Full backward compatibility
+-  Same performance characteristics
+-  Comprehensive documentation
 
 The gem now handles a wider variety of data types, making it more versatile for educational purposes and demonstrations.
 
-**Happy Sorting!** 🌀
+**Happy Sorting!** 
 
 ---
 

data/lib/vibe/sort.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "sort/version"
-
-module Vibe
-  module Sort
-    class Error < StandardError; end
-    # Your code goes here...
-  end
-end
+# Compatibility shim: Bundler autorequires "vibe/sort" for a gem named
+# "vibe-sort", so `gem "vibe-sort"` in a Gemfile loads the real library
+# without needing an explicit `require "vibe_sort"`.
+require_relative "../vibe_sort"

data/lib/vibe_sort/client.rb

@@ -7,17 +7,26 @@ module VibeSort
 
     # Initialize a new VibeSort client
     #
-    # @param api_key [String] OpenAI API key
-    # @param temperature [Float] Temperature for the model (default: 0.0)
-    # @raise [ArgumentError] if api_key is invalid
+    # @param api_key [String] API key for the selected provider
+    # @param temperature [Float] Temperature for the model (default: 0.0).
+    #   Ignored by providers whose current models do not accept it (Anthropic).
+    # @param provider [Symbol, String] LLM provider: :openai (default), :anthropic, or :gemini
+    # @param model [String, nil] Model ID override (nil uses the provider's default)
+    # @raise [ArgumentError] if api_key or provider is invalid
     #
-    # @example
+    # @example OpenAI (default provider)
     #   client = VibeSort::Client.new(api_key: ENV['OPENAI_API_KEY'])
-    def initialize(api_key:, temperature: 0.0)
-      @config = Configuration.new(api_key: api_key, temperature: temperature)
+    #
+    # @example Anthropic Claude
+    #   client = VibeSort::Client.new(provider: :anthropic, api_key: ENV['ANTHROPIC_API_KEY'])
+    #
+    # @example Google Gemini with a custom model
+    #   client = VibeSort::Client.new(provider: :gemini, api_key: ENV['GEMINI_API_KEY'], model: 'gemini-2.5-pro')
+    def initialize(api_key:, temperature: 0.0, provider: :openai, model: nil)
+      @config = Configuration.new(api_key: api_key, temperature: temperature, provider: provider, model: model)
     end
 
-    # Sort an array of numbers and/or strings using OpenAI API
+    # Sort an array of numbers and/or strings using the configured provider's API
     #
     # @param array [Array] Array of numbers and/or strings to sort
     # @return [Hash] Result hash with keys:
@@ -44,6 +53,7 @@ module VibeSort
     # @example API error
     #   result = client.sort([1, 2, 3]) # with invalid API key
     #   #=> { success: false, sorted_array: [], error: "OpenAI API error: Invalid API key" }
+    #   # The error prefix names the configured provider (OpenAI, Anthropic, or Gemini)
     def sort(array)
       # Validate input
       unless valid_input?(array)