deliverable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6939d9e02d7269dc2704b727f9aaf27b2374e271d88c03e48c126bfe6695132a
+  data.tar.gz: e0eca76ecdfc1478bfe3c507555c4b59054ac898a658499a573b86478f87c684
+SHA512:
+  metadata.gz: 101133007279b3c6610dcad60d8c9dcb0a86a8ff9d5f7aa215d29cbe3cba1d0daf53bcd75f32afdc07ac56e154f019fd537dc4b6b15a7f2670cacaa9ae474c58
+  data.tar.gz: d7af7df7bb8ac409e211103eca6851ab63142cc9dc38fece9ae7cd9e3b2d00fea250466c97e8ea69ebc9702712bece6f1e5f0b182b2e42e971bc6adc862c7aba

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erik Strömberg
+
+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/README.md

@@ -0,0 +1,121 @@
+# deliverable
+
+Honest email verification for Ruby. Tells you when an address is deliverable, when it's a fake, and — crucially — when it doesn't know.
+
+```ruby
+Deliverable.verify("ada@example.com")
+# => #<Deliverable::Result valid? classification="valid" score=95 ...>
+```
+
+```
+$ deliverable ada@example.com
+VALID  ada@example.com  score 95
+
+  ✓ syntax
+  ✓ mx record
+  ✓ smtp deliverable
+  ✗ disposable
+  ✗ accepts any email
+```
+
+## Why another one
+
+Most email verification gems run a syntax regex, check for an MX record, optionally do an SMTP `RCPT TO`, and return a boolean. That falls apart in practice:
+
+- **Multi-port SMTP fallback.** Many mail servers reject port 25 from residential / cloud IPs but accept 587 or 465. `deliverable` tries `25 → 587 → 465` and only gives up when all three fail.
+- **Catch-all detection.** A server that says yes to `ada@example.com` and *also* says yes to `definitely-does-not-exist-8482@example.com` isn't actually verifying anything. `deliverable` probes a fake address per domain and downgrades the result to `risky` when it catches one.
+- **Problematic-server awareness.** Gmail, Outlook, Office 365, Mimecast, and Proofpoint actively defeat SMTP probing. Other gems return false positives or false negatives on these. `deliverable` recognises them and returns `risky` with `smtp_failed_assumption: true` instead of pretending to know.
+- **Three-way classification.** `valid`, `risky`, `invalid` — not a boolean. Risky is where the money is: it's the address that *might* bounce.
+
+## Install
+
+```ruby
+gem "deliverable"
+```
+
+Or:
+
+```sh
+gem install deliverable
+```
+
+## Library
+
+```ruby
+require "deliverable"
+
+Deliverable.configure do |c|
+  c.sender_email  = "verify@yourdomain.com"
+  c.sender_domain = "yourdomain.com"
+end
+
+result = Deliverable.verify("ada@example.com")
+
+result.valid?           # => true
+result.classification   # => "valid" | "risky" | "invalid"
+result.score            # => 0..100
+result.errors           # => []
+result.warnings         # => []
+result.checks           # => { syntax:, mx_record:, smtp_deliverable:, disposable:, typo_suggestion:, accepts_any_email: }
+result.to_h             # full hash for logging / serialization
+```
+
+Skip the SMTP probe (faster, lower confidence):
+
+```ruby
+Deliverable.verify("ada@example.com", smtp: false)
+```
+
+## CLI
+
+```
+$ deliverable ada@example.com
+$ deliverable ada@example.com --no-smtp
+$ deliverable ada@example.com --json
+$ deliverable ada@example.com --timeout 5
+$ deliverable ada@gmial.com         # suggests gmail.com via Levenshtein
+```
+
+Exit codes:
+
+| Code | Meaning |
+|------|---------|
+| 0    | valid   |
+| 1    | risky   |
+| 2    | invalid |
+| 64   | usage error |
+
+## Sender identity
+
+SMTP servers want to know who's asking. `deliverable` issues `EHLO sender_domain` and `MAIL FROM:<sender_email>` during the probe. There is no default — running an SMTP probe without configuring a sender raises `Deliverable::SenderNotConfigured`. Lying about your identity to a stranger's mail server tends to cause silent rejections, so the gem refuses to do it for you.
+
+Configure once:
+
+```ruby
+Deliverable.configure do |c|
+  c.sender_email  = "verify@yourdomain.com"
+  c.sender_domain = "yourdomain.com"
+end
+```
+
+Or per-call:
+
+```ruby
+Deliverable.verify("ada@gmail.com", sender_email: "verify@you.com", sender_domain: "you.com")
+```
+
+The CLI reads `DELIVERABLE_SENDER_EMAIL` and `DELIVERABLE_SENDER_DOMAIN` from the environment, or accepts `--sender` and `--helo` flags. If you don't need the SMTP probe, pass `smtp: false` (library) or `--no-smtp` (CLI) and no sender is required.
+
+## Notes on accuracy
+
+SMTP verification is a probabilistic signal, not a guarantee. Servers can lie, greylist, or reject all probes from your IP regardless of recipient. `deliverable` returns `classification: "risky"` whenever it had to make an assumption — that's the "I don't know" answer most other gems hide as `valid`.
+
+If you're verifying at scale, expect to be IP-blocked by major providers (Gmail, Outlook). Either rotate sender IPs, accept that bulk gmail/outlook checks return `risky`, or use a paid API.
+
+## When you outgrow this gem
+
+`deliverable` is built and maintained by [PeopleDB](https://peopledb.co). If you need more than per-address SMTP probing — bulk verification, deliverability data merged with profile information from multiple sources, or contact lookups by LinkedIn / GitHub identifier — the [PeopleDB API](https://peopledb.co) does that.
+
+## License
+
+MIT.

data/exe/deliverable

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "json"
+require "deliverable"
+
+options = {
+  smtp: true,
+  json: false,
+  timeout: 10,
+  sender_email: ENV["DELIVERABLE_SENDER_EMAIL"],
+  sender_domain: ENV["DELIVERABLE_SENDER_DOMAIN"]
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: deliverable EMAIL [options]"
+  opts.separator ""
+  opts.separator "Verifies whether an email address is deliverable."
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("--no-smtp", "Skip SMTP probe (syntax + MX only)") { options[:smtp] = false }
+  opts.on("--json", "Emit JSON instead of human output") { options[:json] = true }
+  opts.on("--timeout N", Integer, "SMTP timeout in seconds (default 10)") { |n| options[:timeout] = n }
+  opts.on("--sender EMAIL", "Sender email used in MAIL FROM") { |e| options[:sender_email] = e }
+  opts.on("--helo DOMAIN", "Domain used in HELO/EHLO") { |d| options[:sender_domain] = d }
+  opts.on("-v", "--version", "Show version") { puts Deliverable::VERSION; exit 0 }
+  opts.on("-h", "--help", "Show this help") { puts opts; exit 0 }
+end
+
+parser.parse!
+
+def smtp_mark(value, pass, fail_, skip)
+  case value
+  when true then pass
+  when false then fail_
+  else skip
+  end
+end
+
+def smtp_note(value)
+  case value
+  when nil then "skipped"
+  when true then nil
+  when false then "rejected"
+  end
+end
+
+def catchall_mark(value, pass, warn, skip)
+  case value
+  when true then warn
+  when false then pass
+  else skip
+  end
+end
+
+def catchall_note(value)
+  case value
+  when nil then "not checked"
+  when true then "yes"
+  when false then "no"
+  end
+end
+
+email = ARGV.shift
+if email.nil? || email.empty?
+  warn parser
+  exit 64
+end
+
+begin
+  result = Deliverable.verify(
+    email,
+    smtp: options[:smtp],
+    timeout: options[:timeout],
+    sender_email: options[:sender_email],
+    sender_domain: options[:sender_domain]
+  )
+rescue Deliverable::SenderNotConfigured
+  warn "deliverable: SMTP probing requires a sender identity."
+  warn ""
+  warn "  Pass --sender verify@yourdomain.com --helo yourdomain.com,"
+  warn "  set DELIVERABLE_SENDER_EMAIL and DELIVERABLE_SENDER_DOMAIN,"
+  warn "  or run with --no-smtp to skip the probe."
+  exit 64
+end
+
+if options[:json]
+  puts JSON.pretty_generate(result.to_h)
+else
+  color = case result.classification
+          when "valid" then "\e[32m"
+          when "risky" then "\e[33m"
+          else "\e[31m"
+          end
+  reset = "\e[0m"
+  dim = "\e[2m"
+
+  puts "#{color}#{result.classification.upcase}#{reset}  #{result.email}  #{dim}score #{result.score}#{reset}"
+  puts
+
+  green = "\e[32m"
+  red = "\e[31m"
+  yellow = "\e[33m"
+  pass = "#{green}✓#{reset}"
+  fail_ = "#{red}✗#{reset}"
+  warn = "#{yellow}!#{reset}"
+  skip = "#{dim}·#{reset}"
+
+  rows = []
+  rows << ["syntax",           result.checks[:syntax]            ? pass : fail_, nil]
+  rows << ["MX record",        result.checks[:mx_record]         ? pass : fail_, nil]
+  rows << ["SMTP deliverable", smtp_mark(result.checks[:smtp_deliverable], pass, fail_, skip), smtp_note(result.checks[:smtp_deliverable])]
+  rows << ["disposable",       result.checks[:disposable]        ? warn : pass,  result.checks[:disposable] ? "yes" : "no"]
+  rows << ["catch-all",        catchall_mark(result.checks[:accepts_any_email], pass, warn, skip), catchall_note(result.checks[:accepts_any_email])]
+  if result.checks[:typo_suggestion]
+    rows << ["typo suggestion", warn, result.checks[:typo_suggestion]]
+  end
+
+  width = rows.map { |label, _, _| label.length }.max
+  rows.each do |label, mark, note|
+    line = "  #{mark} #{label.ljust(width)}"
+    line += "  #{dim}#{note}#{reset}" if note
+    puts line
+  end
+
+  if result.errors.any?
+    puts
+    result.errors.each { |e| puts "  \e[31m!\e[0m #{e}" }
+  end
+
+  if result.warnings.any?
+    puts
+    result.warnings.each { |w| puts "  \e[33m!\e[0m #{w}" }
+  end
+end
+
+case result.classification
+when "valid" then exit 0
+when "risky" then exit 1
+else exit 2
+end

data/lib/deliverable/result.rb

@@ -0,0 +1,36 @@
+module Deliverable
+  class Result
+    attr_reader :email, :score, :score_details, :errors, :warnings, :checks
+
+    def initialize(email:, score:, score_details:, classification:, errors:, warnings:, checks:)
+      @email = email
+      @score = score
+      @score_details = score_details
+      @classification = classification
+      @errors = errors
+      @warnings = warnings
+      @checks = checks
+    end
+
+    def valid?
+      @classification != "invalid"
+    end
+
+    def classification
+      @classification
+    end
+
+    def to_h
+      {
+        email: @email,
+        valid: valid?,
+        classification: @classification,
+        score: @score,
+        score_details: @score_details,
+        errors: @errors,
+        warnings: @warnings,
+        checks: @checks
+      }
+    end
+  end
+end

data/lib/deliverable/verifier.rb

@@ -0,0 +1,374 @@
+require "resolv"
+require "net/smtp"
+require "timeout"
+require "valid_email2"
+
+module Deliverable
+  class Verifier
+    PROBLEMATIC_SERVER_PATTERNS = [
+      /migadu\.com$/,
+      /gmail\.com$/,
+      /google\.com$/,
+      /googlemail\.com$/,
+      /outlook\.com$/,
+      /office365\.com$/,
+      /protection\.outlook\.com$/,
+      /proofpoint\.com$/,
+      /mimecast\.com$/
+    ].freeze
+
+    SMTP_PORTS = [25, 587, 465].freeze
+
+    COMMON_DOMAINS = %w[
+      gmail.com yahoo.com hotmail.com outlook.com
+      aol.com icloud.com live.com msn.com
+      proton.me protonmail.com fastmail.com
+    ].freeze
+
+    def initialize(email, smtp: true, timeout: 10, sender_email: nil, sender_domain: nil, logger: nil)
+      @email = email&.strip&.downcase
+      @smtp = smtp
+      @timeout = timeout
+      @sender_email = sender_email || Deliverable.config.sender_email
+      @sender_domain = sender_domain || Deliverable.config.sender_domain
+      @logger = logger || Deliverable.config.logger
+      @errors = []
+      @warnings = []
+      @details = {
+        syntax_valid: false,
+        mx_verified: false,
+        smtp_verified: false,
+        smtp_failed_assumption: false,
+        dns_failed_assumption: false,
+        has_warnings: false,
+        accepts_any_email: false
+      }
+      @accepts_any_email = nil
+    end
+
+    def call
+      ok = run_checks
+      score = calculate_score
+      Result.new(
+        email: @email,
+        score: score,
+        score_details: @details.dup,
+        classification: classification(ok),
+        errors: @errors,
+        warnings: @warnings,
+        checks: {
+          syntax: @details[:syntax_valid],
+          mx_record: @details[:mx_verified],
+          smtp_deliverable: @smtp ? @smtp_result : nil,
+          disposable: disposable?,
+          typo_suggestion: typo_suggestion,
+          accepts_any_email: @accepts_any_email
+        }
+      )
+    end
+
+    private
+
+    def run_checks
+      return false unless validate_syntax
+
+      check_disposable
+      check_typo
+
+      return false unless validate_mx
+      return false if @smtp && !validate_smtp
+
+      true
+    end
+
+    def validate_syntax
+      if @email.nil? || @email.empty?
+        @errors << "Email address is required"
+        return false
+      end
+
+      unless ValidEmail2::Address.new(@email).valid?
+        @errors << "Email address format is invalid"
+        return false
+      end
+
+      @details[:syntax_valid] = true
+      true
+    end
+
+    def validate_mx
+      domain = extract_domain
+      return false unless domain
+
+      unless mx_or_a_record?(domain)
+        @errors << "Email domain does not accept mail (no MX record found)"
+        return false
+      end
+
+      true
+    end
+
+    def mx_or_a_record?(domain)
+      resolver = Resolv::DNS.new
+      mx = resolver.getresources(domain, Resolv::DNS::Resource::IN::MX)
+
+      if mx.empty?
+        a = resolver.getresources(domain, Resolv::DNS::Resource::IN::A)
+        if a.any?
+          @details[:mx_verified] = true
+          return true
+        end
+        return false
+      end
+
+      @details[:mx_verified] = true
+      true
+    rescue Resolv::ResolvError, Resolv::ResolvTimeout
+      false
+    rescue StandardError => e
+      log "DNS lookup failed for #{domain}: #{e.message}"
+      @details[:dns_failed_assumption] = true
+      true
+    end
+
+    def validate_smtp
+      require_sender!
+      result = smtp_deliverable_check
+      unless result
+        @errors << "Email address does not exist on the mail server"
+      end
+      result
+    end
+
+    def require_sender!
+      missing = []
+      missing << "sender_email" if @sender_email.nil? || @sender_email.empty?
+      missing << "sender_domain" if @sender_domain.nil? || @sender_domain.empty?
+      return if missing.empty?
+
+      raise SenderNotConfigured, <<~MSG.strip
+        SMTP probing requires #{missing.join(" and ")}. Configure with:
+
+          Deliverable.configure do |c|
+            c.sender_email  = "verify@yourdomain.com"
+            c.sender_domain = "yourdomain.com"
+          end
+
+        Or pass sender_email:/sender_domain: to Deliverable.verify, or skip the
+        SMTP probe with smtp: false.
+      MSG
+    end
+
+    def smtp_deliverable_check
+      return @smtp_result unless @smtp_result.nil?
+
+      domain = extract_domain
+      @smtp_result = false
+      return @smtp_result unless domain
+
+      mail_server = pick_mail_server(domain)
+      return @smtp_result unless mail_server
+
+      outcome = probe_ports(mail_server)
+
+      case outcome
+      when :verified
+        @details[:smtp_verified] = true
+        check_catch_all(mail_server)
+        @smtp_result = true
+      when :assumed
+        @details[:smtp_failed_assumption] = true
+        @smtp_result = true
+      else
+        @smtp_result = false
+      end
+    rescue StandardError => e
+      log "SMTP check failed for #{@email}: #{e.message}"
+      @details[:smtp_failed_assumption] = true
+      @smtp_result = true
+    end
+
+    def pick_mail_server(domain)
+      resolver = Resolv::DNS.new
+      mx = resolver.getresources(domain, Resolv::DNS::Resource::IN::MX)
+      return mx.min_by(&:preference).exchange.to_s unless mx.empty?
+
+      a = resolver.getresources(domain, Resolv::DNS::Resource::IN::A)
+      a.empty? ? nil : domain
+    rescue StandardError => e
+      log "MX lookup failed for #{domain}: #{e.message}"
+      nil
+    end
+
+    def probe_ports(mail_server)
+      last = nil
+
+      SMTP_PORTS.each do |port|
+        result = attempt_rcpt(mail_server, port, @email)
+
+        return result if result == :verified || result == :invalid
+
+        last = result
+        next if result == :connection_failed
+
+        return result if result == :assumed && !problematic_server?(mail_server)
+      end
+
+      problematic_server?(mail_server) ? :assumed : (last || :assumed)
+    end
+
+    def attempt_rcpt(mail_server, port, recipient)
+      Timeout.timeout(@timeout) do
+        smtp = Net::SMTP.new(mail_server, port)
+        smtp.enable_starttls_auto if port == 587 || port == 465
+
+        smtp.start(@sender_domain) do |conn|
+          conn.mailfrom(@sender_email)
+          begin
+            conn.rcptto(recipient)
+            return :verified
+          rescue Net::SMTPFatalError => e
+            classify_fatal(e.message)
+          rescue Net::SMTPServerBusy, Net::SMTPSyntaxError, Net::SMTPAuthenticationError
+            return :assumed
+          end
+        end
+      end
+    rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
+      :connection_failed
+    rescue Net::SMTPAuthenticationError, Net::SMTPServerBusy
+      :assumed
+    rescue StandardError => e
+      log "SMTP probe failed for #{recipient} on #{mail_server}:#{port}: #{e.message}"
+      :connection_failed
+    end
+
+    def classify_fatal(message)
+      msg = message.to_s.downcase
+      if msg.include?("550") || msg.include?("551") ||
+          msg.include?("user unknown") || msg.include?("recipient unknown") ||
+          msg.include?("mailbox unavailable")
+        :invalid
+      elsif msg.include?("421") || msg.include?("450") || msg.include?("451") || msg.include?("temporary")
+        :assumed
+      else
+        :assumed
+      end
+    end
+
+    def check_catch_all(mail_server)
+      domain = extract_domain
+      return unless domain
+
+      fake = "definitely-does-not-exist-#{rand(10**10)}@#{domain}"
+      result = SMTP_PORTS.each do |port|
+        outcome = attempt_rcpt(mail_server, port, fake)
+        break :accepted if outcome == :verified
+        break :rejected if outcome == :invalid
+      end
+
+      if result == :accepted
+        @accepts_any_email = true
+        @details[:accepts_any_email] = true
+      else
+        @accepts_any_email = false
+      end
+    end
+
+    def problematic_server?(mail_server)
+      PROBLEMATIC_SERVER_PATTERNS.any? { |p| mail_server.match?(p) }
+    end
+
+    def check_disposable
+      if disposable?
+        @warnings << "Email appears to be from a disposable email service"
+      end
+    end
+
+    def disposable?
+      ValidEmail2::Address.new(@email).disposable?
+    rescue StandardError
+      false
+    end
+
+    def check_typo
+      suggestion = typo_suggestion
+      @warnings << "Did you mean: #{suggestion}?" if suggestion
+    end
+
+    def typo_suggestion
+      return nil unless @email&.include?("@")
+
+      domain = extract_domain
+      closest = COMMON_DOMAINS.map { |d| [d, levenshtein(domain, d)] }.min_by { |_, dist| dist }
+      return nil unless closest
+
+      d, dist = closest
+      return nil if dist == 0
+      return nil if dist > 2 || dist >= domain.length / 2.0
+
+      @email.sub(/#{Regexp.escape(domain)}\z/, d)
+    end
+
+    def levenshtein(a, b)
+      return b.length if a.empty?
+      return a.length if b.empty?
+
+      m = Array.new(a.length + 1) { Array.new(b.length + 1, 0) }
+      (0..a.length).each { |i| m[i][0] = i }
+      (0..b.length).each { |j| m[0][j] = j }
+
+      (1..a.length).each do |i|
+        (1..b.length).each do |j|
+          cost = a[i - 1] == b[j - 1] ? 0 : 1
+          m[i][j] = [m[i - 1][j] + 1, m[i][j - 1] + 1, m[i - 1][j - 1] + cost].min
+        end
+      end
+
+      m[a.length][b.length]
+    end
+
+    def extract_domain
+      return nil unless @email&.include?("@")
+      @email.split("@").last
+    end
+
+    def calculate_score
+      @details[:has_warnings] = @warnings.any?
+      score = 0
+      score += 20 if @details[:syntax_valid]
+
+      if @details[:mx_verified]
+        score += 40
+      elsif @details[:dns_failed_assumption]
+        score += 15
+      end
+
+      if @details[:smtp_verified]
+        score += @details[:accepts_any_email] ? 15 : 35
+      elsif @details[:smtp_failed_assumption]
+        score += 10
+      elsif @smtp
+        score += 5
+      else
+        score += 20
+      end
+
+      score -= [@warnings.length * 8, 25].min if @warnings.any?
+      score.clamp(0, 100)
+    end
+
+    def classification(ok)
+      return "invalid" unless ok
+      return "risky" if @details[:accepts_any_email]
+      return "risky" if @details[:dns_failed_assumption] || @details[:smtp_failed_assumption]
+      return "risky" if disposable?
+      return "risky" if @warnings.any?
+      "valid"
+    end
+
+    def log(message)
+      @logger&.warn(message)
+    end
+  end
+end

data/lib/deliverable/version.rb

@@ -0,0 +1,3 @@
+module Deliverable
+  VERSION = "0.1.0"
+end

data/lib/deliverable.rb

@@ -0,0 +1,37 @@
+require_relative "deliverable/version"
+require_relative "deliverable/result"
+require_relative "deliverable/verifier"
+
+module Deliverable
+  class Error < StandardError; end
+  class SenderNotConfigured < Error; end
+
+  class Configuration
+    attr_accessor :sender_email, :sender_domain, :logger, :default_timeout
+
+    def initialize
+      @sender_email = nil
+      @sender_domain = nil
+      @logger = nil
+      @default_timeout = 10
+    end
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.verify(email, smtp: true, timeout: nil, sender_email: nil, sender_domain: nil)
+    Verifier.new(
+      email,
+      smtp: smtp,
+      timeout: timeout || config.default_timeout,
+      sender_email: sender_email,
+      sender_domain: sender_domain
+    ).call
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: deliverable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Erik Strömberg
+bindir: exe
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: valid_email2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Verifies whether an email address is actually deliverable. Multi-port
+  SMTP fallback, catch-all detection, and awareness of mail servers (Gmail, Outlook,
+  Mimecast) that block SMTP probing — so it tells you when it doesn't know instead
+  of guessing.
+email:
+- erik@peopledb.co
+executables:
+- deliverable
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/deliverable
+- lib/deliverable.rb
+- lib/deliverable/result.rb
+- lib/deliverable/verifier.rb
+- lib/deliverable/version.rb
+homepage: https://github.com/peopledb/deliverable
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/peopledb/deliverable
+  source_code_uri: https://github.com/peopledb/deliverable
+  changelog_uri: https://github.com/peopledb/deliverable/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: 'Honest email verification: syntax, MX, SMTP RCPT, and catch-all detection.'
+test_files: []