imap 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 587a50234d8535c27ceeace7941c30f74147ef68bb65e835eb84b04878bc91c7
+  data.tar.gz: 2778297913ec8a25dcb39e014cff11c538b8eee0bb706846d13045f744995096
+SHA512:
+  metadata.gz: fb5a7c2332893c2a2fd9c0728480a6c098302d14a389986c1003cc5b547ec85a9dbff6ab4f7927bfdc5039b45d54719da17a1b1b4e0e88f35a03d741cb096313
+  data.tar.gz: 8ac81274dd278a5fd71fa3434837df50c39a73db7e311e9ddfdc15e51e7320992383987a129f321cbda3a6ad8c2a8da55ab02c272a713e2ed8a9ff72f7af0768

data/README.md

@@ -0,0 +1,77 @@
+# imap
+
+A Ruby wrapper around Net::IMAP with an elegant DSL for searching, reading, and managing email.
+
+## Features
+
+- Clean, hash-based search interface
+- Intuitive message accessors
+- No Rails dependency - works anywhere
+- Zero external dependencies beyond net-imap
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'imap'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install imap
+```
+
+## Usage
+```ruby
+require 'imap'
+
+# Connect and authenticate
+imap_client = Imap.setup(
+  server: 'imap.thoran.com',
+  username: 'code@thoran.com',
+  password: 'bigsecret',
+  mailbox: 'INBOX' # optional/default
+)
+
+messages = imap_client.search(
+  from: 'noreply@example.com',
+  subject: 'Payday Loans',
+  since: '18-DEC-2025',
+  seen: false
+)
+
+# Access message details
+messages.each do |message|
+  puts message.subject
+  puts message.from
+  puts message.to
+  puts message.body
+  puts message.urls # Extracted URLs from body
+end
+
+# Mark messages as read
+messages.first.mark_as_read
+
+# Clean up
+imap_client.bye
+```
+
+## Contributing
+
+1. Fork it (https://github.com/thoran/imap/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new pull request
+
+## License
+
+MIT

data/imap.gemspec

@@ -0,0 +1,33 @@
+# imap.gemspec
+
+require_relative './lib/Imap/VERSION'
+
+Gem::Specification.new do |spec|
+  spec.name = 'imap'
+
+  spec.version = Imap::VERSION
+  spec.date = '2025-12-20'
+
+  spec.summary = "IMAP for Ruby made easy."
+  spec.description = "A Ruby wrapper around Net::IMAP with an elegant DSL for searching, reading, and managing email."
+
+  spec.author = 'thoran'
+  spec.email = 'code@thoran.com'
+  spec.homepage = 'https://github.com/thoran/imap'
+  spec.license = 'MIT'
+
+  spec.required_ruby_version = '>= 2.7'
+
+  spec.add_dependency 'net-imap', "~> 0.4"
+
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+
+  spec.files = [
+    'imap.gemspec',
+    Dir['lib/**/*.rb'],
+    'README.md',
+    Dir['test/**/*.rb']
+  ].flatten
+  spec.require_paths = ['lib']
+end

data/lib/Imap/Message.rb

@@ -0,0 +1,67 @@
+# Imap/Message.rb
+# Imap::Message
+
+# Usage:
+# 1. Imap::Message.search(imap_client, {from: 'noreply@example.com'})
+# 2. Imap::Message.new(message_id, imap_client)
+# 3. Imap::Message.new(message_id, imap_client).body
+# 4. Imap::Message.new(message_id, imap_client).urls
+# 5. Imap::Message.new(message_id, imap_client).mark_as_read
+# 6. Imap::Message.new(message_id, imap_client).subject
+# 7. Imap::Message.new(message_id, imap_client).from
+# 8. Imap::Message.new(message_id, imap_client).to
+
+require_relative './Search'
+
+class Imap
+  class Message
+    class << self
+
+      def search(imap_client, **search_criteria)
+        message_ids = Imap::Search.new(imap_client, search_criteria).message_ids
+        message_ids.collect{|message_id| Imap::Message.new(message_id, imap_client)}
+      end
+      alias_method :find, :search
+
+    end # class << self
+
+    attr_accessor :imap_client
+    attr_accessor :message_id
+
+    def body
+      @body ||= fetch_data('BODY[TEXT]').first.attr['BODY[TEXT]']
+    end
+
+    def subject
+      @subject ||= fetch_data('BODY[HEADER.FIELDS (SUBJECT)]').first.attr['BODY[HEADER.FIELDS (SUBJECT)]'].sub(/^Subject: /, '').strip
+    end
+
+    def from
+      @from ||= fetch_data('BODY[HEADER.FIELDS (FROM)]').first.attr['BODY[HEADER.FIELDS (FROM)]'].sub(/^From: /, '').strip
+    end
+
+    def to
+      @to ||= fetch_data('ENVELOPE').first.attr['ENVELOPE'].to.map{|addr| addr.mailbox + '@' + addr.host}
+    end
+
+    def urls
+      body.scan(/https?:\/\/[\S]+/)
+    end
+
+    def mark_as_seen
+      imap_client.imap.store(@message_id, '+FLAGS', [:Seen])
+    end
+    alias_method :mark_as_read, :mark_as_seen
+
+    private
+
+    def initialize(message_id = nil, imap_client = nil)
+      @message_id = message_id
+      @imap_client = imap_client
+    end
+
+    def fetch_data(*attrs)
+      @fetch_data = imap_client.imap.fetch(message_id, [*attrs])
+    end
+  end
+end

data/lib/Imap/Search.rb

@@ -0,0 +1,143 @@
+# Imap/Search.rb
+# Imap::Search
+
+# Usage:
+# 1. Imap::Search.new.not.subject('Payday Loans').answered.from('noreply@example.com').all
+# 2. Imap::Search.new({from: 'noreply@example.com', answered: true})
+
+# Notes:
+# 1. List of search keys taken from RFC-3501 (INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1), http://tools.ietf.org/html/rfc3501.
+
+class Imap
+  class Search
+
+    ALL_SEARCH_KEYS = %w{
+      ALL
+      ANSWERED
+      BCC
+      BEFORE
+      BODY
+      CC
+      DELETED
+      DRAFT
+      FLAGGED
+      FROM
+      HEADER
+      KEYWORD
+      LARGER
+      NEW
+      NOT
+      OLD
+      ON
+      OR
+      RECENT
+      SEEN
+      SENTBEFORE
+      SENTON
+      SENTSINCE
+      SINCE
+      SMALLER
+      SUBJECT
+      TEXT
+      TO
+      UID
+      UNANSWERED
+      UNDELETED
+      UNDRAFT
+      UNFLAGGED
+      UNKEYWORD
+      UNSEEN
+    }
+
+    BOOLEAN_SEARCH_KEYS = %w{
+      ANSWERED UNANSWERED
+      DELETED UNDELETED
+      DRAFT UNDRAFT
+      FLAGGED UNFLAGGED
+      NEW
+      OLD
+      RECENT
+      SEEN UNSEEN
+    }
+
+    GENERAL_SEARCH_KEYS = %w{
+      BCC
+      BEFORE
+      BODY
+      CC
+      FROM
+      HEADER
+      KEYWORD UNKEYWORD
+      LARGER
+      ON
+      SENTBEFORE
+      SENTON
+      SENTSINCE
+      SINCE
+      SMALLER
+      SUBJECT
+      TEXT
+      TO
+      UID
+    }
+
+    BOOLEAN_SEARCH_KEYS.each do |boolean_search_key|
+      define_method boolean_search_key do |value = true|
+        criteria.merge!(boolean_search_key.to_sym => value)
+      end
+    end
+
+    GENERAL_SEARCH_KEYS.each do |general_search_key|
+      define_method general_search_key do |value|
+        criteria.merge!(general_search_key.to_sym => value)
+      end
+    end
+
+    attr_accessor :criteria
+    attr_accessor :imap_client
+
+    def general_operator?(search_key)
+      GENERAL_SEARCH_KEYS.include?(search_key)
+    end
+
+    def boolean_operator?(search_key)
+      BOOLEAN_SEARCH_KEYS.include?(search_key)
+    end
+
+    def to_imap_search_keys
+      criteria.inject([]) do |m, kv|
+        key, value = kv.first.to_s.upcase, kv.last
+        case
+        when general_operator?(key)
+          m << general_to_imap_search_key(key, value)
+        when boolean_operator?(key)
+          m << boolean_to_imap_search_key(key, value)
+        end
+      end.flatten
+    end
+
+    def general_to_imap_search_key(key, value)
+      [key, value]
+    end
+
+    def boolean_to_imap_search_key(key, value)
+      if value
+        [key]
+      else
+        ['NOT', key]
+      end
+    end
+
+    def message_ids
+      imap_client.imap.search(to_imap_search_keys)
+    end
+    alias_method :all, :message_ids
+
+    private
+
+    def initialize(imap_client = nil, criteria = nil)
+      @criteria = criteria || {}
+      @imap_client = imap_client
+    end
+  end
+end

data/lib/Imap/VERSION.rb

@@ -0,0 +1,3 @@
+class Imap
+  VERSION = '0.4.0'
+end

data/lib/imap.rb

@@ -0,0 +1,82 @@
+# imap.rb
+# Imap
+
+require 'net/imap'
+require_relative './Imap/Message'
+
+class Imap
+  class << self
+
+    def setup(config)
+      raise ArgumentError, "Server must be specified" unless config[:server]
+      imap_client = Imap.new(**config)
+      if config[:username] && config[:password]
+        imap_client.login(username: config[:username], password: config[:password])
+      end
+      if config[:mailbox]
+        imap_client.mailbox = config[:mailbox]
+      end
+      imap_client
+    end
+
+  end # class << self
+
+  attr_accessor :server
+  attr_accessor :ssl
+  attr_accessor :username
+  attr_accessor :password
+  attr_reader :mailbox
+
+  def login(username: nil, password: nil)
+    username ||= @username
+    password ||= @password
+    begin
+      imap.login(username, password)
+      true
+    rescue Net::IMAP::NoResponseError, Net::IMAP::BadResponseError
+      false
+    end
+  end
+
+  def mailbox=(mailbox)
+    @mailbox = mailbox
+    imap.select(mailbox)
+  end
+
+  def search(criteria = {})
+    Imap::Message.search(self, **criteria)
+  end
+  alias_method :messages, :search
+  alias_method :find, :search
+
+  def bye
+    logout
+    disconnect
+  end
+
+  def logout
+    imap.logout
+  end
+
+  def disconnect
+    imap.disconnect
+  end
+
+  def imap
+    @imap ||= Net::IMAP.new(server, ssl: @ssl)
+  end
+
+  def ssl?
+    @ssl
+  end
+
+  private
+
+  def initialize(server:, ssl: true, username: nil, password: nil, mailbox: 'INBOX')
+    @server = server
+    @ssl = ssl
+    @username = username
+    @password = password
+    @mailbox = mailbox
+  end
+end

data/test/Imap/Message_test.rb

@@ -0,0 +1,112 @@
+# test/Imap/Message_test.rb
+
+require_relative '../test_helper'
+
+describe Imap::Message do
+  let(:client) do
+    mock_imap = MockIMAP.new('imap.example.com', ssl: true)
+    Net::IMAP.stub(:new, mock_imap) do
+      Imap.setup(
+        server: 'imap.example.com',
+        username: 'user@example.com',
+        password: 'secret'
+      )
+    end
+  end
+
+  let(:imap_message) do
+    Imap::Message.new(1, client)
+  end
+
+  describe '.search' do
+    it 'returns an array of messages' do
+      messages = Imap::Message.search(client, from: 'test@example.com')
+      _(messages).must_be_instance_of Array
+      _(messages.first).must_be_instance_of Imap::Message
+    end
+
+    it 'has find alias' do
+      _((Imap::Message.method(:find) == Imap::Message.method(:search))).must_equal true
+    end
+  end
+
+  describe '#body' do
+    it 'returns the message body' do
+      _(imap_message.body).must_match /Mock body/
+    end
+
+    it 'caches the result' do
+      first_call = imap_message.body
+      second_call = imap_message.body
+      _(first_call.object_id).must_equal second_call.object_id
+    end
+  end
+
+  describe '#subject' do
+    it 'returns the subject without prefix' do
+      _(imap_message.subject).must_match(/Mock Subject/)
+      _(imap_message.subject).wont_match(/^Subject:/)
+    end
+
+    it 'strips whitespace' do
+      _(imap_message.subject).must_equal(imap_message.subject.strip)
+    end
+  end
+
+  describe '#from' do
+    it 'returns the from address' do
+      _(imap_message.from).must_match(/sender@example.com/)
+    end
+
+    it 'removes From: prefix' do
+      _(imap_message.from).wont_match(/^From:/)
+    end
+  end
+
+  describe '#to' do
+    it 'returns an array of email addresses' do
+      addresses = imap_message.to
+      _(addresses).must_be_instance_of(Array)
+      _(addresses.first).must_match(/@/)
+    end
+
+    it 'formats addresses correctly' do
+      addresses = imap_message.to
+      _(addresses.first).must_equal('user@example.com')
+    end
+  end
+
+  describe '#urls' do
+    it 'extracts http URLs from body' do
+      imap_message.stub(:body, 'Check out http://example.com and https://test.com') do
+        urls = imap_message.urls
+        _(urls).must_include('http://example.com')
+        _(urls).must_include('https://test.com')
+      end
+    end
+
+    it 'returns empty array when no URLs' do
+      imap_message.stub(:body, 'No URLs here') do
+        _(urls = imap_message.urls).must_be_empty
+      end
+    end
+  end
+
+  describe '#mark_as_seen' do
+    it 'marks the message as seen' do
+      _(imap_message.mark_as_seen).must_be_nil
+    end
+
+    it 'has mark_as_read alias' do
+      _((imap_message.method(:mark_as_read) == imap_message.method(:mark_as_seen))).must_equal true
+    end
+  end
+
+  describe '#initialize' do
+    it 'accepts message_id and imap_client' do
+      test_message = Imap::Message.new(42, client)
+      _(test_message.message_id).must_equal(42)
+      _(test_message.imap_client).must_equal(client)
+    end
+  end
+end

data/test/Imap/Search_test.rb

@@ -0,0 +1,92 @@
+# test/Imap/Search_test.rb
+
+require_relative '../test_helper'
+
+describe Imap::Search do
+  let(:client) do
+    mock_imap = MockIMAP.new('imap.example.com', ssl: true)
+    Net::IMAP.stub(:new, mock_imap) do
+      Imap.setup(
+        server: 'imap.example.com',
+        username: 'user@example.com',
+        password: 'secret'
+      )
+    end
+  end
+
+  let(:search) do
+    Imap::Search.new(client, {})
+  end
+
+  describe '#to_imap_search_keys' do
+    it 'converts general search keys' do
+      test_search = Imap::Search.new(client, from: 'test@example.com')
+      keys = test_search.to_imap_search_keys
+      _(keys).must_include 'FROM'
+      _(keys).must_include 'test@example.com'
+    end
+
+    it 'converts boolean search keys' do
+      test_search = Imap::Search.new(client, seen: false)
+      keys = test_search.to_imap_search_keys
+      _(keys).must_include 'NOT'
+      _(keys).must_include 'SEEN'
+    end
+
+    it 'handles multiple criteria' do
+      test_search = Imap::Search.new(client, from: 'test@example.com', seen: true)
+      keys = test_search.to_imap_search_keys
+      _(keys.length).must_be :>, 2
+    end
+  end
+
+  describe '#message_ids' do
+    it 'returns an array of message IDs' do
+      ids = search.message_ids
+      _(ids).must_be_instance_of Array
+    end
+
+    it 'has all alias' do
+      _((search.method(:all) == search.method(:message_ids))).must_equal true
+    end
+  end
+
+  describe '#boolean_operator?' do
+    it 'returns true for boolean operators' do
+      _(search.boolean_operator?('SEEN')).must_equal true
+      _(search.boolean_operator?('ANSWERED')).must_equal true
+    end
+
+    it 'returns false for general operators' do
+      _(search.boolean_operator?('FROM')).must_equal false
+    end
+  end
+
+  describe '#general_operator?' do
+    it 'returns true for general operators' do
+      _(search.general_operator?('FROM')).must_equal true
+      _(search.general_operator?('SUBJECT')).must_equal true
+    end
+
+    it 'returns false for boolean operators' do
+      _(search.general_operator?('SEEN')).must_equal false
+    end
+  end
+
+  describe '#initialize' do
+    it 'accepts imap_client parameter' do
+      test_search = Imap::Search.new(client)
+      _(test_search.imap_client).must_equal client
+    end
+
+    it 'accepts criteria parameter' do
+      test_search = Imap::Search.new(client, from: 'test@example.com')
+      _(test_search.criteria).must_equal({ from: 'test@example.com' })
+    end
+
+    it 'defaults criteria to empty hash' do
+      test_search = Imap::Search.new(client)
+      _(test_search.criteria).must_equal({})
+    end
+  end
+end

data/test/imap_test.rb

@@ -0,0 +1,119 @@
+# test/imap_test.rb
+
+require_relative './test_helper'
+
+describe Imap do
+  let(:client) do
+    Net::IMAP.stub(:new, MockIMAP.new('imap.example.com', ssl: true)) do
+      Imap.setup(
+        server: 'imap.example.com',
+        username: 'user@example.com',
+        password: 'secret',
+        mailbox: 'INBOX'
+      )
+    end
+  end
+
+  describe ".setup" do
+    it 'creates a new client instance' do
+      _(client).must_be_instance_of(Imap)
+    end
+
+    it 'requires a server parameter' do
+      _(proc{Imap.setup({})}).must_raise(ArgumentError)
+    end
+
+    it 'sets the server' do
+      _(client.server).must_equal 'imap.example.com'
+    end
+
+    it 'defaults ssl to true' do
+      _(client.ssl?).must_equal true
+    end
+
+    it 'defaults mailbox to INBOX' do
+      _(client.mailbox).must_equal 'INBOX'
+    end
+  end
+
+  describe "#login" do
+    it 'returns true on successful login' do
+      Net::IMAP.stub(:new, MockIMAP.new('imap.example.com', ssl: true)) do
+        test_client = Imap.new(server: 'imap.example.com')
+        result = test_client.login(username: 'user', password: 'pass')
+        _(result).must_equal true
+      end
+    end
+
+    it 'returns false on failed login' do
+      mock = MockIMAP.new('imap.example.com', ssl: true)
+      def mock.login(username, password)
+        mock_response = OpenStruct.new(data: OpenStruct.new(text: 'Authentication failed'))
+        raise Net::IMAP::BadResponseError, mock_response
+      end
+
+      Net::IMAP.stub(:new, mock) do
+        test_client = Imap.new(server: 'imap.example.com')
+        result = test_client.login(username: 'user', password: 'wrong')
+        _(result).must_equal false
+      end
+    end
+  end
+
+  describe "#mailbox=" do
+    it 'sets the mailbox' do
+      Net::IMAP.stub(:new, MockIMAP.new('imap.example.com', ssl: true)) do
+        test_client = Imap.new(server: 'imap.example.com')
+        test_client.mailbox = 'Sent'
+        _(test_client.mailbox).must_equal 'Sent'
+      end
+    end
+  end
+
+  describe "#search" do
+    it 'returns an array of Message objects' do
+      Net::IMAP.stub(:new, MockIMAP.new('imap.example.com', ssl: true)) do
+        test_client = Imap.setup(
+          server: 'imap.example.com',
+          username: 'user',
+          password: 'pass'
+        )
+        messages = test_client.search(from: 'test@example.com')
+        _(messages).must_be_instance_of Array
+        _(messages.first).must_be_instance_of Imap::Message
+      end
+    end
+
+    it 'has messages and find aliases' do
+      _((client.method(:messages) == client.method(:search))).must_equal true
+      _((client.method(:find) == client.method(:search))).must_equal true
+    end
+  end
+
+  describe "#initialize" do
+    it 'accepts server parameter' do
+      test_client = Imap.new(server: 'mail.example.com')
+      _(test_client.server).must_equal 'mail.example.com'
+    end
+
+    it 'accepts ssl parameter' do
+      test_client = Imap.new(server: 'mail.example.com', ssl: false)
+      _(test_client.ssl?).must_equal false
+    end
+
+    it 'accepts username parameter' do
+      test_client = Imap.new(server: 'mail.example.com', username: 'test@example.com')
+      _(test_client.username).must_equal 'test@example.com'
+    end
+
+    it 'accepts password parameter' do
+      test_client = Imap.new(server: 'mail.example.com', password: 'secret')
+      _(test_client.password).must_equal 'secret'
+    end
+
+    it 'accepts mailbox parameter' do
+      test_client = Imap.new(server: 'mail.example.com', mailbox: 'Sent')
+      _(test_client.mailbox).must_equal 'Sent'
+    end
+  end
+end

data/test/test_all.rb

@@ -0,0 +1,6 @@
+# test/test_all.rb
+
+require_relative './test_helper'
+require_relative './Imap_test'
+require_relative './Imap/Message_test'
+require_relative './Imap/Search_test'

data/test/test_helper.rb

@@ -0,0 +1,74 @@
+# test/test_helper.rb
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'ostruct'
+require_relative '../lib/imap'
+
+class MockIMAP
+  attr_reader :login_called
+  attr_reader :logout_called
+  attr_reader :search_called
+  attr_reader :search_criteria
+  attr_reader :select_called
+  attr_reader :selected_mailbox
+
+  def login(username, password)
+    @login_called = true
+    @username = username
+    @password = password
+  end
+
+  def select(mailbox)
+    @select_called = true
+    @selected_mailbox = mailbox
+  end
+
+  def search(criteria)
+    @search_called = true
+    @search_criteria = criteria
+    [1, 2, 3]
+  end
+
+  def fetch(message_id, attrs)
+    [OpenStruct.new(attr: mock_fetch_attrs(message_id, attrs))]
+  end
+
+  def store(message_id, flags, values); end
+
+  def logout
+    @logout_called = true
+  end
+
+  def disconnect; end
+
+  private
+
+  def initialize(server, ssl:)
+    @server = server
+    @ssl = ssl
+    @login_called = false
+    @select_called = false
+    @search_called = false
+    @logout_called = false
+  end
+
+  def mock_fetch_attrs(message_id, attrs)
+    result = {}
+    attrs.each do |attr|
+      case attr
+      when 'BODY[TEXT]'
+        result['BODY[TEXT]'] = "Mock body for message #{message_id}"
+      when 'BODY[HEADER.FIELDS (SUBJECT)]'
+        result['BODY[HEADER.FIELDS (SUBJECT)]'] = "Subject: Mock Subject #{message_id}\r\n"
+      when 'BODY[HEADER.FIELDS (FROM)]'
+        result['BODY[HEADER.FIELDS (FROM)]'] = "From: sender@example.com\r\n"
+      when 'ENVELOPE'
+        result['ENVELOPE'] = OpenStruct.new(
+          to: [OpenStruct.new(mailbox: 'user', host: 'example.com')]
+        )
+      end
+    end
+    result
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: imap
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- thoran
+bindir: bin
+cert_chain: []
+date: 2025-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-imap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !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: A Ruby wrapper around Net::IMAP with an elegant DSL for searching, reading,
+  and managing email.
+email: code@thoran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- imap.gemspec
+- lib/Imap/Message.rb
+- lib/Imap/Search.rb
+- lib/Imap/VERSION.rb
+- lib/imap.rb
+- test/Imap/Message_test.rb
+- test/Imap/Search_test.rb
+- test/imap_test.rb
+- test/test_all.rb
+- test/test_helper.rb
+homepage: https://github.com/thoran/imap
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.2
+specification_version: 4
+summary: IMAP for Ruby made easy.
+test_files: []