snerdmq 0.2.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc0a9b03631b02d3f9e17a6a998dde6e09620bb240c8f34c28c6c99593919d2
-  data.tar.gz: 874f0ab2ccc9b6335cbdf42ea1735aba9e2350df03dbb12b2f6113293a73524e
+  metadata.gz: e1d73035fba1f4d5bd42c382bc5c8798db8597ddbbe2829cf6fd9323747751e7
+  data.tar.gz: 42b2633c35e968f1640a603b4d4ab59de9cdf7257f9b045c53af7cd97ba68c21
 SHA512:
-  metadata.gz: a54654999159b9985a6bb90930dcbdd54a917c95b0dc36ba85c4450b0ade16f93cf491fef47eafa1b6887f3ccd9f599ddc3574ff6b344ea3bd4937e53d53d4a8
-  data.tar.gz: be4656365456108a065abfe48fbde90e65102218eb46c591ba772c77aedeeb0b2498c04bb9ddd21ca996c3711ea40088672c03a9efdecafed0af303a6292380b
+  metadata.gz: 11a0de6095c802f2a6aa85d0ca5ce4af45b5be5f8763212e10f74608b9ff3a79cdc71929e5937ee8961076f9094124f19321ac9bf9ae78b42133ba86ffbffcbc
+  data.tar.gz: ba85ccfeff123d455ea3694709ca2a7825ab535fc70b6963d29c6d6486a9126b38f0b2d868afd5d0e05964dc9d143fa7a8b9efb3499f7b79e0df383f3f945b0b

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,19 @@
+## Description
+Please include a summary of the change and which issue is fixed (if any). Please also include relevant motivation and context.
+
+## Type of Change
+Please check the options that are relevant.
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Documentation update
+- [ ] Performance improvement
+
+## Checklist
+- [ ] I have read the `CONTRIBUTING.md` document.
+- [ ] My code follows the style guidelines of this project.
+- [ ] I have performed a self-review of my own code.
+- [ ] I have commented my code, particularly in hard-to-understand areas.
+- [ ] I have made corresponding changes to the documentation.
+- [ ] I have added tests that prove my fix is effective or that my feature works.
+- [ ] New and existing unit tests pass locally with my changes.

data/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.2'
+        bundler-cache: true
+
+    - name: Run tests
+      run: bundle exec rake test

data/.snerdata/tasks/tasks.log

@@ -1 +1,2 @@
 {"taskId":"ruby-job-1","retryCount":0,"maxRetries":3,"retryAfterHours":0.0,"retryAfterTime":"2026-08-14T09:43:50.902732Z","taskData":"{\"user_id\":\"ruby_master\",\"message\":\"matz\"}","taskType":"test_ruby_job"}
+{"taskId":"ruby-job-1","retryCount":0,"maxRetries":3,"retryAfterHours":0.0,"retryAfterTime":"2026-08-16T10:42:24.239760Z","taskData":"{\"user_id\":\"ruby_master\",\"message\":\"matz\"}","taskType":"test_ruby_job","executeAt":"2026-08-16T10:42:24.239760Z"}

data/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+# Contributing to SnerdMQ
+
+First off, thank you for considering contributing to SnerdMQ! It's people like you that make open-source software such a great community to learn, inspire, and create.
+
+## How to Contribute
+
+### 1. Fork and Clone
+We use the standard GitHub Fork and Pull Request workflow. 
+1. Click the "Fork" button in the top right corner of the repository.
+2. Clone your fork locally: `git clone https://github.com/YOUR_USERNAME/snerdmq-ruby.git`
+
+### 2. Branching Strategy
+Create a branch for your feature or bug fix:
+```bash
+git checkout -b feat/your-feature-name
+# or
+git checkout -b fix/your-bugfix-name
+```
+Never commit directly to the `main` or `master` branch of your fork.
+
+### 3. Making Changes
+- Ensure your code follows the existing conventions and paradigms in the repository.
+- Write clear, concise, and descriptive commit messages.
+- If you're fixing a bug, please add a test that catches the bug to ensure it doesn't happen again.
+- If you're adding a feature, please add appropriate tests and update the `README.md` if necessary.
+
+### 4. Submitting a Pull Request
+1. Push your branch to your fork: `git push origin your-branch-name`
+2. Go to the original SnerdMQ repository and click "Compare & pull request".
+3. Fill out the provided Pull Request template completely. Provide context, what you've changed, and how you tested it.
+4. Wait for a maintainer to review your code. We may request some changes before it can be merged!
+
+## Code of Conduct
+By participating in this project, you are expected to uphold a welcoming, respectful, and inclusive environment for everyone.

data/Gemfile.lock

@@ -1,13 +1,29 @@
 PATH
   remote: .
   specs:
-    snerdmq (1.0.0)
+    snerdmq (0.3.0)
+      faye-websocket
+      puma
+      rack
 
 GEM
   remote: https://rubygems.org/
   specs:
+    base64 (0.1.1)
+    eventmachine (1.2.7)
+    faye-websocket (0.12.0)
+      eventmachine (>= 0.12.0)
+      websocket-driver (>= 0.8.0)
     minitest (5.27.0)
+    nio4r (2.7.5)
+    puma (8.0.2)
+      nio4r (~> 2.0)
+    rack (3.2.7)
     rake (13.4.2)
+    websocket-driver (0.8.2)
+      base64
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
 
 PLATFORMS
   arm64-darwin-24

data/README.md

@@ -1,28 +1,49 @@
 <div align="center">
   <img src="./assets/Designer-9.png" height="120" alt="SnerdMQ Ruby Logo" />
-  <h1>💎 SnerdMQ Ruby SDK v0.2.1</h1>
+  <h1>💎 SnerdMQ Ruby SDK v0.3.2</h1>
   <p>A zero-config, C-speed background job queue for Ruby. Ditch Redis and Sidekiq for lightweight, persistent background jobs.</p>
 
   [![Gem Version](https://badge.fury.io/rb/snerdmq.svg)](https://badge.fury.io/rb/snerdmq)
+  [![Docs](https://img.shields.io/badge/docs-speed--nerd.github.io-blue)](https://speed-nerd.github.io/docs/)
 </div>
 
 This is the official Ruby SDK wrapper for **SnerdMQ**. It handles all JSON-RPC communication and `IO.popen` orchestration so you can write lightning-fast background jobs without managing any external databases like Redis or Postgres.
 
-## ✨ v0.2.1 AI-Era Features
+## ✨ v0.3.2 AI Features
 - **Smart API Rate-Limiting**: Natively tracks `rate_limit_group` execution velocity to prevent 429 "Too Many Requests" API errors.
 - **Payload-Hashing Deduplication**: Automatically computes cryptographic hashes to drop duplicate tasks instantly.
 - **Dynamic Float Prioritization**: A native Binary Max-Heap bypasses standard FIFO rules for high urgency tasks.
+- **Progress Streaming & Live Dashboard**: Handlers can stream progress updates to a built-in React UI dashboard served by the SDK.
 - **Ditch Sidekiq & Redis**: Gives your Ruby apps persistent state, automatic retries, and dead-letter queues right out of the box with zero external infrastructure.
 - **Zero Rust Required**: Our gem installation script automatically downloads the pre-compiled C-speed Rust binary for your OS.
 - **Thread Safe**: Uses native Ruby `Thread`s and `Mutex` locks to orchestrate I/O without blocking your main event loop.
 
-### ⚙️ Advanced Task Configuration (v0.2.1)
+### ⚙️ Advanced Task Configuration (v0.3.2)
 To power complex AI workflows, tasks can now be configured with advanced orchestration parameters:
 
 * **`auto_dedupe` (`true/false`)**: If set to `true`, the daemon computes a cryptographic hash of the `task_type` and `data`. If an identical payload is currently sitting in the queue pending execution, this new task is silently dropped. Excellent for preventing duplicate generative AI requests from trigger-happy users!
 * **`urgency_score` (`Float`)**: A value (e.g. `0.99`) used to bypass the standard FIFO queue. SnerdMQ uses a true Binary Max-Heap to continually float tasks with the highest urgency score to the very front of the execution line. Standard tasks default to `0.0`.
 * **`rate_limit_group` (`String`)**: A custom string (e.g. `"openai_api"` or `"db_writes"`) that groups tasks together for backpressure control.
 * **`max_per_minute` (`Integer`)**: Used in conjunction with `rate_limit_group`. If the queue processes more tasks in this group than the allowed limit within a 60-second rolling window, further tasks in this group are temporarily paused. This natively prevents 429 "Too Many Requests" errors when bursting third-party APIs.
+* **`execute_at` (`String` | `Time`)**: A timestamp of when the job should be executed in the future.
+* **`retry_after_hours` (`Float`)**: Backoff in **hours** before a failed job is retried (default `0.0`). See *Cron Jobs vs. Retryable Jobs* below.
+* **`cron` (`String`)**: A cron expression (e.g. `"0 * * * *"`) for recurring jobs. Shorthands like `"2h"` or `"10m"` are also supported.
+* **`webhook_url` (`String`)**: By providing a webhook URL, SnerdMQ will completely bypass your local Ruby blocks and dispatch the task payload via an HTTP POST request directly to the specified URL.
+* **`max_execution_seconds` (`Integer`)**: Optional hard timeout in seconds. If execution takes longer, it's marked as failed.
+
+### Note on Hard Timeouts (`max_execution_seconds`)
+When `max_execution_seconds` is provided, the Ruby SDK wraps the execution of your handler in a `Timeout.timeout` block. If the task takes longer than the timeout, a `Timeout::Error` is raised and the execution will be marked as failed. The background Rust daemon also enforces this timeout at the IPC level.
+
+### 🌐 HTTP Webhooks (Serverless Execution)
+You can configure a task to execute externally via an HTTP POST request. By setting a `webhook_url`, the internal background processor will skip any registered handlers (`queue.register_handler`) and directly invoke the HTTP endpoint.
+
+If the HTTP endpoint returns a non-200 status code, it triggers a retry. If it permanently fails (reaches `max_retries`), the Dead Letter Queue event is automatically fired via a final HTTP POST to the same `webhook_url` but with the header `X-SnerdMQ-Event: MaxRetriesReached`.
+
+### 🕒 Cron Jobs vs. Retryable Jobs
+When using the new scheduling features, it is important to understand the difference between Cron and Retry behaviors:
+> - **A Cron Job** is a *Repeatable Job* that executes again **only after a success**, on a fixed schedule.
+> - **A Retryable Job** is a *Recovery Job* that executes again **only after a failure**, attempting to recover using the `retry_after_hours` backoff.
+> - **Combined:** If a Cron Job fails, it temporarily uses `retry_after_hours` to retry until it recovers. Once it succeeds, it goes back to ticking on its standard cron schedule!
 
 ## 📦 Installation
 
@@ -65,17 +86,28 @@ end
 queue.start_listening
 puts "SnerdMQ Ruby SDK is listening for jobs..."
 
-# 4. Enqueue a job from anywhere in your codebase (Now with v0.2.1 AI Features!)
+# 4. Enqueue a job from anywhere in your codebase
 queue.enqueue(
   task_id: "email-123",
   task_type: "send_email",
   data: { "to" => "john@wick.com", "subject" => "Continental Update" },
   max_retries: 3,
-  retry_after_hours: 0.0,
+  retry_after_hours: 0.5,      # Wait 30 minutes before retrying a failed job
   rate_limit_group: "email_api",
-  max_per_minute: 100,
-  auto_dedupe: true,
-  urgency_score: 0.99
+  max_per_minute: 100
+)
+
+# 5. Need scheduling, deduplication, or serverless execution? All
+# orchestration options are opt-in — combine only what you need:
+queue.enqueue(
+  task_id: "email-digest-1",
+  task_type: "send_email",
+  data: { "to" => "john@wick.com", "subject" => "Daily Digest" },
+  cron: "0 8 * * *",           # Run every day at 08:00
+  auto_dedupe: true,           # Drop identical pending payloads
+  urgency_score: 0.99,         # Float to the front of the queue
+  webhook_url: "https://api.example.com/webhook", # Execute via HTTP instead of local blocks
+  max_execution_seconds: 300   # Hard timeout
 )
 
 # Keep main thread alive
@@ -84,7 +116,7 @@ sleep
 
 ### ☠️ Dead Letter Queue (Handling Permanent Failures)
 
-When a task fails repeatedly and exhausts its `maxRetries`, the SnerdMQ daemon permanently moves it to the Dead Letter Queue. You can hook into this event to alert your team, update your database, or send a Slack message by registering a Max Retry Handler.
+When a task fails repeatedly and exhausts its `max_retries`, the SnerdMQ daemon permanently moves it to the Dead Letter Queue. You can hook into this event to alert your team, update your database, or send a Slack message by registering a Max Retry Handler.
 
 ```ruby
 # 5. Catch tasks that have permanently failed (Dead Letter Queue)
@@ -95,6 +127,46 @@ end
 
 ---
 
+## 📊 Live Dashboard
+
+SnerdMQ ships with a built-in **React UI dashboard** served directly by the SDK — no extra services or ports to manage in your infrastructure. It gives you a real-time window into your queue:
+
+- **Live stats**: total enqueued, processed, and failed jobs
+- **Recent Jobs table**: per-task status (`queued`, `active`, `completed`, `failed`, `dead_letter`), retry counts, and badges showing which features a task uses (cron / webhook / timeout)
+- **Real-time Progress Stream**: live output from `yield_progress` calls in your handlers
+
+```ruby
+queue = Snerdmq::SnerdQueue.new
+
+# Start the built-in dashboard on http://localhost:9090
+queue.start_dashboard(port: 9090)
+
+# ... register handlers, start listening, enqueue jobs ...
+```
+
+Then open **http://localhost:9090** in your browser. The dashboard UI automatically uses HTTP polling to stay up to date (progress events included), and the SDK also exposes a small JSON API (`/api/stats`, `/api/tasks`, `/api/progress`) if you want to build your own tooling on top. The dashboard assets ship inside the gem — nothing extra to deploy.
+
+> **Note:** `start_dashboard` only serves the UI — your jobs keep running whether or not the dashboard is open.
+
+---
+
+## 📡 Progress Reporting
+
+Long-running handlers can stream live updates to the Dashboard's Progress Stream (ideal for streaming LLM tokens or multi-step ETL work):
+
+```ruby
+queue.register_handler("generate_report") do |data|
+  (1..10).each do |step|
+    do_work(step)
+    queue.yield_progress("Step #{step}/10 complete")
+  end
+end
+```
+
+> `yield_progress` must be called **inside a task handler** — the SDK tracks which task is currently executing so each update lands on the right job in the dashboard.
+
+---
+
 ## 🌍 Advanced: Distributed Scaling
 
 By default, the SDK spins up the Rust daemon which writes the queue to a local file (`.snerdata/tasks/tasks.log`). 

data/bin/snerdmq-install

@@ -5,7 +5,7 @@ require 'uri'
 require 'fileutils'
 require 'rbconfig'
 
-REPO = "greyhands2/snerdmq"
+REPO = "speed-nerd/snerdmq"
 VERSION = "v0.1.1"
 
 # Determine OS and Architecture

data/lib/snerdmq/queue.rb

@@ -1,5 +1,7 @@
 require 'json'
 require 'thread'
+require 'timeout'
+require 'time'
 
 module Snerdmq
   class SnerdQueue
@@ -72,7 +74,7 @@ module Snerdmq
       end
     end
 
-    def enqueue(task_id:, task_type:, data:, max_retries: 3, retry_after_hours: 0.0, rate_limit_group: nil, max_per_minute: nil, auto_dedupe: false, urgency_score: nil)
+    def enqueue(task_id:, task_type:, data:, max_retries: 3, retry_after_hours: 0.0, rate_limit_group: nil, max_per_minute: nil, auto_dedupe: false, urgency_score: nil, execute_at: nil, cron: nil, webhook_url: nil, max_execution_seconds: nil)
       raise "[Snerd] Cannot enqueue task: Queue is not running. Call start_listening first." if @io.nil? || @shutting_down
       
       payload = {
@@ -88,6 +90,13 @@ module Snerdmq
       payload[:max_per_minute] = max_per_minute if max_per_minute
       payload[:auto_dedupe] = auto_dedupe if auto_dedupe
       payload[:urgency_score] = urgency_score if urgency_score
+      
+      if execute_at
+        payload[:execute_at] = execute_at.respond_to?(:iso8601) ? execute_at.iso8601 : execute_at.to_s
+      end
+      payload[:cron] = cron if cron
+      payload[:webhook_url] = webhook_url if webhook_url
+      payload[:max_execution_seconds] = max_execution_seconds if max_execution_seconds
 
       cond = ConditionVariable.new
       result = nil
@@ -126,18 +135,6 @@ module Snerdmq
       @io.close if @io && !@io.closed?
     end
 
-    private
-
-    def send_message(msg)
-      @stdin_mutex.synchronize do
-        return if @shutting_down || @io.nil? || @io.closed?
-        @io.puts(msg.to_json)
-        @io.flush
-      end
-    rescue Errno::EPIPE
-      # Broken pipe if the daemon died unexpectedly
-    end
-
     def listen_to_stdout
       @io.each_line do |line|
         next if line.strip.empty?
@@ -170,6 +167,9 @@ module Snerdmq
               warn "[Snerd] Error from engine: #{msg['message']}"
             end
           elsif msg["action"] == "progress"
+            # Persist progress events so the dashboard (which falls back to
+            # HTTP polling in Ruby) can display them in the Progress Stream.
+            append_progress_event(msg)
             @ws_mutex.synchronize do
               @ws_clients.each do |ws|
                 ws.send(msg.to_json)
@@ -208,6 +208,7 @@ module Snerdmq
     def handle_execute(msg)
       task_id = msg["task_id"]
       task_type = msg["task_type"]
+      max_execution_seconds = msg["max_execution_seconds"]
       
       raw_data = msg["task_data"]
       task_data = raw_data.is_a?(String) ? JSON.parse(raw_data) : raw_data
@@ -229,12 +230,25 @@ module Snerdmq
 
       begin
         Thread.current[:snerd_task_id] = task_id
-        handler.call(task_data)
+        if max_execution_seconds
+          Timeout.timeout(max_execution_seconds) do
+            handler.call(task_data)
+          end
+        else
+          handler.call(task_data)
+        end
         send_message({
           action: "result",
           task_id: task_id,
           status: "success"
         })
+      rescue Timeout::Error
+        send_message({
+          action: "result",
+          task_id: task_id,
+          status: "error",
+          error_msg: "Task execution timed out after #{max_execution_seconds} seconds"
+        })
       rescue => e
         send_message({
           action: "result",
@@ -253,6 +267,7 @@ module Snerdmq
 
     def start_dashboard(port: 8080)
       require 'rack'
+      require 'puma'
       require 'faye/websocket'
       require 'json'
       
@@ -283,26 +298,43 @@ module Snerdmq
           else
             return [404, {}, ['Dashboard UI not found']]
           end
+        elsif req.get? && req.path == '/api/progress'
+          events = []
+          progress_path = File.join(@storage_path || './.snerdata', 'progress_events.log')
+          if File.exist?(progress_path)
+            File.readlines(progress_path).last(100).each do |line|
+              begin
+                ev = JSON.parse(line)
+                events << ev if ev.is_a?(Hash) && ev['ts']
+              rescue
+              end
+            end
+          end
+          return [200, { 'Content-Type' => 'application/json' }.merge(cors_headers), [events.to_json]]
         elsif req.get? && req.path == '/api/stats'
           stats = { enqueued: 0, processed: 0, failed: 0 }
+          tasks_map = {}
           tasks_path = File.join(@storage_path || './.snerdata', 'tasks', 'tasks.log')
           if File.exist?(tasks_path)
             File.readlines(tasks_path).each do |line|
               next if line.strip.empty?
               begin
                 t = JSON.parse(line)
-                stats[:enqueued] += 1
-                if t['deletedAt']
-                  if t['lastJobError']
-                    stats[:failed] += 1
-                  else
-                    stats[:processed] += 1
-                  end
-                end
+                tasks_map[t['taskId']] = t if t['taskId']
               rescue
               end
             end
           end
+          tasks_map.values.each do |t|
+            stats[:enqueued] += 1
+            if t['deletedAt']
+              if t['LastJobError']
+                stats[:failed] += 1
+              else
+                stats[:processed] += 1
+              end
+            end
+          end
           return [200, { 'Content-Type' => 'application/json' }.merge(cors_headers), [stats.to_json]]
         elsif req.get? && req.path == '/api/tasks'
           tasks_map = {}
@@ -321,9 +353,23 @@ module Snerdmq
           formatted = []
           tasks_map.values.each do |t|
             if t['deletedAt']
-              status = t['lastJobError'] ? 'failed' : 'completed'
+              if t['LastJobError'] && (t['retryCount'] || 0) >= (t['maxRetries'] || 3)
+                status = 'dead_letter'
+              elsif t['LastJobError']
+                status = 'failed'
+              else
+                status = 'completed'
+              end
+            elsif t['LastJobError']
+              status = 'failed'
             else
-              status = t['lastJobError'] ? 'failed' : 'queued'
+              status = 'queued'
+              if t['executeAt']
+                begin
+                  status = 'active' if Time.parse(t['executeAt']) <= Time.now
+                rescue
+                end
+              end
             end
             formatted << {
               id: t['taskId'],
@@ -332,7 +378,10 @@ module Snerdmq
               progress: 0,
               retryCount: t['retryCount'] || 0,
               maxRetries: t['maxRetries'] || 3,
-              retryAfterTime: t['retryAfterTime']
+              retryAfterTime: t['retryAfterTime'],
+              cronExpression: t['cronExpression'],
+              webhookUrl: t['webhookUrl'],
+              maxExecutionSeconds: t['maxExecutionSeconds']
             }
           end
           return [200, { 'Content-Type' => 'application/json' }.merge(cors_headers), [formatted.first(50).to_json]]
@@ -343,9 +392,39 @@ module Snerdmq
 
       Thread.new do
         puts "[Snerd] Dashboard running on http://localhost:#{port}"
-        Rack::Handler::Puma.run(app, Port: port, Silent: true)
+        server = Puma::Server.new(app)
+        server.add_tcp_listener('0.0.0.0', port)
+        server.run
+      end
+    end
+
+    private
+
+    def append_progress_event(msg)
+      dir = @storage_path || './.snerdata'
+      return unless File.directory?(dir)
+      path = File.join(dir, 'progress_events.log')
+
+      event = { ts: Time.now.to_f, task_id: msg['task_id'], data: msg['data'] }.to_json
+      File.open(path, 'a') { |f| f.puts(event) }
+
+      # Keep the file bounded: retain only the most recent events
+      if File.size(path) > 512 * 1024
+        lines = File.readlines(path).map(&:strip).reject(&:empty?)
+        File.write(path, lines.last(200).join("\n") + "\n")
       end
+    rescue
+      # Never break the listener loop over progress persistence
     end
 
+    def send_message(msg)
+      @stdin_mutex.synchronize do
+        return if @shutting_down || @io.nil? || @io.closed?
+        @io.puts(msg.to_json)
+        @io.flush
+      end
+    rescue Errno::EPIPE, Errno::EIO, IOError
+      # Broken pipe / IO error if the daemon died unexpectedly
+    end
   end
-end
+end

data/snerdmq.gemspec

@@ -3,13 +3,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "snerdmq"
-  spec.version       = "0.2.1"
+  spec.version       = "0.3.2"
   spec.authors       = ["Greyhands2"]
   spec.email         = ["developer@example.com"]
 
   spec.summary       = "A zero-config, persistent background job queue for Ruby."
   spec.description   = "The official Ruby SDK for the SnerdMQ Rust daemon. Execute robust, lightning-fast background jobs without Redis."
-  spec.homepage      = "https://github.com/greyhands2/snerdmq-ruby"
+  spec.homepage      = "https://github.com/speed-nerd/snerdmq-ruby"
   spec.license       = "MIT"
 
   spec.files         = Dir.chdir(File.expand_path(__dir__)) do