ruby-qmail 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Allen Fair
+
+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.rdoc

@@ -0,0 +1,66 @@
+= ruby-qmail
+
+The RubyQmail Plugin provides support for the Qmail MTA and helpers for creating data-aware applications
+While initially intended to operate in a large-scale Qmail environment, some of these features may be useful for
+applications on other platforms. In fact, this plugin is not required if you are using Qmail because
+ActionMailer's sendmail and smtp configurations will work for simple Qmail installations.
+
+NOTE: This is still in an early stage of development, but has been tested to insert email into the qmail queue
+via the qmail-queue and QMQP protocols.
+
+== Using ruby-qmail
+
+Ruby Qmail takes a message in 3 parts
+* The envelope return path. This is not necessarily the same as the From: header, and is the email address to which
+  bounces will be sent. This should most likely be a special address used to identify the mailing being sent, 
+  containing the message number or other identifier, and perhaps the source of the message.  For example:
+   bounces-messageid@example.com
+  Ruby-Qmail used VERP (Variable Envelope Return Path) by default, so bounces will be returned in the form
+   bounces-messageid-recipientmailbox=recipientdomain@example.com
+  for individual returns. Qmail will also send a report to the return path (without the recipient address encoded) 
+   bounces-messageid-@example.com
+  with addresses and error messages for all undeliverable addresses.
+* Recipient List. This is either a String containing an email address (only the user@domain part), an array of
+  email addresses, or a file of email addresses (one per line), or any other object implementing Enumerable.
+* Message Data. This is a String or Filename of a raw RFC822 message, with full message headers, body parts and 
+  attachments, ususally composed via Tmail or Rmail.
+
+Call the insert command
+  RubyQmail::Queue.insert "bounces-123@example.com", ['recipient@email.com',...], message_file
+The call returns true if the message was inserted. If you want more control and information, you can run it as:
+  rqq = RubyQmail::Queue.new 
+  sucess? = rqq.qmail_queue "bounces-123@example.com", ['recipient@email.com',...], message_file
+  puts rqq.response   #=> Response message
+
+You can also specify a set of options on the invocation line as :name=>value parameters after the message file.
+  RubyQmail::Queue.insert "bounces-123@example.com", recipient_file, message_file, :method=>:qmqp
+Options can be
+* :config_file - Location of the YAML file with these config settings for the application/system.
+* :qmail_root - Location of the qmail install, usually /var/qmail
+* :qmqp_port - Where any QMQP daemon process is listening, usually 628
+* :logger - Object used to log any messages, such as RAILS_DEFAULT_LOGGER
+* :qmail_queue - The name of the qmail-queue binary (qmail-queue or qmail-qmqpc or other).
+* :qmqp_servers - The location of the time used to specify the IP address of a QMQPD process
+* :ip - The IP address of a QMQP server
+* :method - either :qmqp or :queue, used on the #insert method
+* :noverp - Do not use VERP encoding on the return path
+* :delimiter - Character to separate the email address and VERP encoding (Qmail prefers '-', others user '+')
+
+== Feature Path
+* Queue management, moving, reporting
+* Bounce handling
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Allen Fair. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ruby-qmail"
+    gem.summary = %Q{Ruby interfaces for Qmail}
+    gem.description = %Q{Provides methods to interact with Qmail to send/queue messages, manage bounces, and manage the queue.}
+    gem.email = "allen.fair@gmail.com"
+    gem.homepage = "http://github.com/afair/ruby-qmail"
+    gem.authors = ["Allen Fair"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ruby-qmail #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/bounce.rb

@@ -0,0 +1,44 @@
+module RubyQmail
+  # Bounce Handler for Qmail Bounce messages. There are typically two types of bounces
+  # * Remote Bounces - When email is accepted by the remote email server, then it cannot be delivered, it
+  # sends the message with its own error message to the Return-Path or sender address (not necessarily the
+  # same one in the From: header--although some non-RFC-compliant servers still will do this). For this 
+  # processing, it is useful to enable VERP (RubyQmail does this). VERP (Variable Envelope Return Path) in
+  # Qmail appends the recipient's email address to each unique delivery, replacing the @ by the = symbol 
+  # (returnpath-recipient=recipdomain@example.com).
+  # * Undeliverable Bounces - An email is sent back to the reuturn path with a formatted report off all undeliverable
+  # addresses (where the remote server could not be reached or accept delivery) and the error message 
+  # generated by Qmail or returned by the Remote server during the SMTP session.
+  class BounceHandler
+
+
+   def initialize(bounce_io)
+     @bounce_io = bounce_io
+   end
+ 
+    # Parses a Qmail bounce message as IO object, then calls block with |address, message| for each bounced address
+    def parse(&block) 
+      address=nil
+      mesage=nil
+      bounces=0
+      @bounce_io.each do |line|
+        break if line =~ /^--- Below this line is a copy of the message\./
+        if line =~ /^<(\S+)>:/
+          address = $1
+          message=''
+          bounces += 1
+        elsif bounces==0
+          next
+        #elsif line ~! /\S/ # empty
+        #  yield address, message
+        elsif line =~ /Remote host said: (.+)/
+          yield address, $1
+          #message += line
+        end
+      end
+      bounces
+    end
+    
+  end
+  
+end

data/lib/config.rb

@@ -0,0 +1,31 @@
+module RubyQmail
+  require 'logger'
+
+  # Configuration for the Qmail system. Loads a configuration YAML file, and accepts a Hash of run-time overrides.
+  class Config
+    attr_reader :options
+    DEFAULTS = {
+      :qmqp_port => 628,
+      :qmail_root => '/var/qmail',
+      :delimiter => '-',
+      :logger    => Logger.new("#{ENV['HOME']}/logs/ruby-qmail.log")
+    }
+    QMQP_SERVERS = '/control/qmqpservers'
+    QMAIL_QUEUE  = '/bin/qmail-queue'
+        
+    def self.load_file(config_file, options={})
+      @options = DEFAULTS.merge(options)
+      if config_file && File.exists?(config_file)
+        @options = YAML.load_file(config_file).merge(@options)
+      end
+      @options[:qmail_queue] ||= @options[:qmail_root] + QMAIL_QUEUE
+      @options[:qmqp_servers] ||= @options[:qmail_root] + QMQP_SERVERS
+      @options
+    end
+    
+    def method_missing(method)
+      @options[method.to_sym]
+    end
+    
+  end
+end

data/lib/netstring.rb

@@ -0,0 +1,13 @@
+module RubyQmail
+  module Netstring
+  
+    # Converts the string to a netstring: "length:value,"
+    def to_netstring()
+      "#{self.size}:#{self},"
+    end
+  end
+end
+  
+class String#:nodoc:
+  include RubyQmail::Netstring
+end

data/lib/queue.rb

@@ -0,0 +1,248 @@
+module RubyQmail
+  
+  class Queue
+    include Process
+    attr_accessor( :return_path, :message, :recipients, :options, :response, :success )
+    QMAIL_QUEUE_SUCCESS = 0
+    QMAIL_ERRORS = {
+      -1 => "Unknown Error",
+       0 => "Success",
+      11 => "Address too long",
+      31 => "Mail server permanently refuses to send the message to any recipients.",
+      51 => "Out of memory.",
+      52 => "Timeout.",
+      53 => "Write error; e.g., disk full.",
+      54 => "Unable to read the message or envelope.",
+      55 => "Unable to read a configuration file.",
+      56 => "Problem making a network connection from this host.",
+      61 => "Problem with the qmail home directory.",
+      62 => "Problem with the queue directory.",
+      63 => "Problem with queue/pid.",
+      64 => "Problem with queue/mess.",
+      65 => "Problem with queue/intd.",
+      66 => "Problem with queue/todo.",
+      71 => "Mail server temporarily refuses to send the message to any recipients.",
+      72 => "Connection to mail server timed out.",
+      73 => "Connection to mail server rejected. ",
+      74 => "Connection to mail server  succeeded,  but  communication  failed.",
+      81 => "Internal bug; e.g., segmentation fault.",
+      91 => "Envelope format error"
+    }
+    
+    # Class Method to place the message into the Qmail queue.
+    def self.insert(return_path, recipients, message, *options)
+      q = Queue.new(return_path, recipients, message, *options)
+      if q.options.has_key?[:ip] || q.options[:method]==:qmqp 
+        q.qmqp
+      else
+        q.qmail_queue
+      end
+    end
+    
+    # Recipients can be a filename, array or other object that responds to :each, or #to_s resolves to an email address
+    # Message can be a filename, string, or other object that responds to :each
+    def initialize(return_path=nil, recipients=nil, message=nil, *options)
+      parameters(return_path, recipients, message, options)
+    end
+      
+    def parameters(return_path, recipients, message, options) #:nodoc:
+      @return_path = return_path if return_path
+      @options     = RubyQmail::Config.load_file( nil, options.last || {})
+      @recipients  = recipients if recipients
+      @recipients  = File.new(@recipients) if @recipients.is_a?(String) && File.exists?(@recipients)
+      @recipients  = [ @recipients.to_s ] unless @recipients.respond_to?(:each)
+      @message     = message if message
+      @message     = File.new(@message) if @message.is_a?(String) && File.exists?(@message)
+      @message     = @message.split(/\n/) if @message.is_a?(String)
+
+      # Edits the return path for VERP. bounces@example.com => bounces-@example.com-@[]
+      if return_path && !@options.has_key?(:noverp)
+        rp1, rp2 = return_path.split(/@/)
+        @return_path = "#{rp1}#{@options[:delimiter]}@#{rp2}" if (rp1.match(/(.)$/)[1] != @options[:delimiter])
+        @return_path += '-@[]' unless @return_path =~ /-@\[\]$/
+      end
+    end
+    
+    # This calls the Qmail-Queue program, so requires qmail to be installed (does not require it to be currently running).
+    def queue(return_path=nil, recipients=nil, message=nil, *options)
+      parameters(return_path, recipients, message, options)
+      @success = run_qmail_queue() do |msg, env|
+        # Send the Message
+        @message.each { |m| msg.puts(m) }
+        msg.close
+
+        env.write('F' + @return_path + "\0")
+        @recipients.each { |r| env.write('T' + r + "\0") }      
+        env.write("\0") # End of "file"
+      end
+      @options[:logger].info("RubyQmail Queue exited:#{@success} #{Queue.qmail_queue_error_message(@success)}")
+      return true if @success == QMAIL_QUEUE_SUCCESS
+      raise Queue.qmail_queue_error_message(@success)
+    end
+    
+    # Maps the qmail-queue exit code to the error message
+    def self.qmail_queue_error_message(code) #:nodoc:
+      "RubyQmail::Queue Error #{code}:" + QMAIL_ERRORS.has_key?(code) ? QMAIL_ERRORS[code]:QMAIL_ERRORS[-1]
+    end
+    
+    # Builds the QMQP request, and opens a connection to the QMQP Server and sends
+    # This implemtents the QMQP protocol, so does not need Qmail installed on the host system.
+    # System defaults will be used if no ip or port given.
+    # Returns true on success, false on failure (see @response), or nul on deferral
+    def qmqp(return_path=nil, recipients=nil, message=nil, *options)
+      parameters(return_path, recipients, message, options)
+      
+      begin
+        ip = @options[:ip] || File.readlines(QMQP_SERVERS).first.chomp
+        #puts "CONNECT #{:ip}, #{@options[:qmqp_port]}"
+        socket = TCPSocket.new(ip, @options[:qmqp_port])
+        raise "QMQP can not connect to #{ip}:#{@options[:qmqp_port]}" unless socket
+        
+        # Build netstring of messagebody+returnpath+recipient...
+        nstr = (@message.map.join("\n")+"\n").to_netstring # { |m| m }.join("\t").to_netstring
+        nstr += @return_path.to_netstring
+        nstr += @recipients.map { |r| r.to_netstring }.join
+        socket.send( nstr.to_netstring, 0 )
+
+        @response = socket.recv(1000) # "23:Kok 1182362995 qp 21894," (its a netstring)
+        @success = case @response.match(/^\d+:([KZD])(.+),$/)[1]
+          when 'K' : true  # success
+          when 'Z' : nil   # deferral
+          when 'D' : false # failure
+          else false
+        end
+        logmsg = "RubyQmail QMQP [#{ip}:#{@options[:qmqp_port]}]: #{@response} return:#{@success}"
+        @options[:logger].info(logmsg)
+        puts logmsg
+        @success
+      rescue Exception => e
+        @options[:logger].error( "QMQP can not connect to #{@opt[:qmqp_ip]}:#{@options[:qmqp_port]} #{e}" )
+        raise e
+      ensure
+        socket.close if socket
+      end
+    end
+    
+    # # Like #qmail_queue, but writes directly to the queue, not via the qmail-queue program
+    # # Is this a good idea? It expects a unique PID per message.
+    # def qmail_queue_direct(return_path=nil, recipients=nil, message=nil, *options)
+    #   parameters(return_path, recipients, message, options)
+    # end
+
+    # def sendmail(return_path=nil, recipients=nil, message=nil, *options)
+    #   parameters(return_path, recipients, message, options)
+    # end
+
+    # Sends email directly via qmail-remote. It does not store in the queue, It will halt the process
+    # and wait for the network event to complete. If multiple recipients are passed, it will run
+    # qmail-remote delivery for each at a time to honor VERP return paths.
+    def qmail_remote(return_path=nil, recipients=nil, message=nil, *options)
+      parameters(return_path, recipients, message, options)
+      rp1, rp2 = @return_path.split(/@/,2)
+      rp = @return_path
+      @recipients.each do |recip|
+        unless @options[:noverp]
+          mailbox, host = recip.split(/@/)
+          rp = "#{rp1}#{mailbox}=#{host}@#{rp2}"
+        end
+
+        @message.rewind if @message.respond_to?(:rewind)
+        cmd = "#{@options[:qmail_root]}+/bin/qmail-remote #{host} #{rp} #{recip}"
+        @success = self.spawn_command(cmd) do |send, recv|
+          @message.each { |m| send.puts m }
+          send.close
+          @response = recv.readpartial(1000)
+        end
+
+        @options[:logger].info("RubyQmail Remote #{recip} exited:#{@success} responded:#{@response}")
+      end
+      return [ @success, @response ] # Last one
+    end
+        
+    # Forks, sets up stdin and stdout pipes, and starts the command. 
+    # IF a block is passed, yeilds to it with [sendpipe, receivepipe], 
+    # returing the exit code, otherwise returns {:send=>, :recieve=>, :pid=>}
+    # qmail-queue does not work with this as it reads from both pipes.
+    def spawn_command(command, &block)
+      child_read, parent_write = IO.pipe # From parent to child(stdin)
+      parent_read, child_write = IO.pipe # From child(stdout) to parent
+      @child = fork
+
+      # Child process
+      unless @child # 
+        $stdin.close # closes FD==0
+        child_read.dup # copies to FD==0
+        child_read.close
+        
+        $stdout.close # closes FD==1
+        child_write.dup # copies to FD==1
+        child_write.close
+
+        Dir.chdir(@options[:qmail_root]) unless @options[:nochdir]
+        exec(command)
+        raise "Exec spawn_command #{command} failed"
+      end
+      
+      # Parent Process with block
+      if block_given?
+        yield(parent_write, parent_read)
+        parent_write.close
+        parent_read.close
+        wait(@child)
+        @success = $? >> 8
+        return @sucess
+      end
+      
+      # Parent process, no block
+      {:send=>parent_write, :receive=>parent_read, :pid=>@child}
+    end
+
+    # Forks, sets up stdin and stdout pipes, and starts qmail-queue. 
+    # IF a block is passed, yields to it with [sendpipe, receivepipe], 
+    # and returns the exist cod, otherwise returns {:msg=>pipe, :env=>pipe, :pid=>@child}
+    # It exits 0 on success or another code on failure. 
+    # Qmail-queue Protocol: Reads mail message from File Descriptor 0, then reads Envelope from FD 1
+    # Envelope Stream: 'F' + sender_email + "\0" + ("T" + recipient_email + "\0") ... + "\0"
+    def run_qmail_queue(command=nil, &block)
+      # Set up pipes and qmail-queue child process
+      msg_read, msg_write = IO.pipe
+      env_read, env_write = IO.pipe
+      @child=fork # child? nil : childs_process_id
+
+      unless @child 
+        ## Set child's stdin(0) to read from msg
+        $stdin.close # FD=0
+        msg_read.dup
+        msg_read.close
+        msg_write.close
+
+        ## Set child's stdout(1) to read from env
+        $stdout.close # FD=1
+        env_read.dup
+        env_read.close
+        env_write.close
+
+        # Change directory and load command
+        Dir.chdir(@options[:qmail_root])
+        exec( command || @options[:qmail_queue] )
+        raise "Exec qmail-queue failed"
+      end
+
+      # Parent Process with block
+      if block_given?
+        yield(msg_write, env_write)
+      # msg_write.close
+        env_write.close
+        wait(@child)
+        @success = $? >> 8
+        # puts "#{$$} parent waited for #{@child} s=#{@success} #{$?.inspect}"
+        return @sucess
+      end
+      
+      # Parent process, no block
+      {:msg=>msg_write, :env=>env_write, :pid=>@child}
+    end
+
+  end
+
+end

data/lib/ruby-qmail.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/netstring"
+require File.dirname(__FILE__) + "/config"
+require File.dirname(__FILE__) + "/queue"
+# require File.dirname(__FILE__) + "/"
+# require File.dirname(__FILE__) + "/"
+# require File.dirname(__FILE__) + "/"

data/spec/ruby-qmail_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'rubygems'
+require 'ruby-debug'
+
+describe "RubyQmail" do
+
+  before(:all) do
+    @rqq = RubyQmail::Queue.new()
+    @rpath = 'allen-whitelist@biglist.com'
+    @recip = %w( allen-1@biglist.com allen-2@biglist.com )
+    @msg   = %q(To: allen-admin@biglist.com
+From: allen-listmaster@biglist.com
+Subject: ruby-qmail
+
+testing 1 2 3. 
+later!
+)
+  end
+  
+  it "should add a #to_netstring method to the string class" do
+    "qmail".to_netstring.should == "5:qmail,"
+  end
+
+  it "should submit a message by qmail-queue" do
+    @rqq.queue( @rpath, @recip, @msg ).should_equal true
+  end
+
+  it "should submit a message by QMQP" do
+    @rqq.qmqp( @rpath, @recip, @msg, :ip=>'173.161.130.227', :qmqp_port=>631 ).should_equal true
+  end
+
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ruby-qmail'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-qmail
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Allen Fair
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-28 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: Provides methods to interact with Qmail to send/queue messages, manage bounces, and manage the queue.
+email: allen.fair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/bounce.rb
+- lib/config.rb
+- lib/netstring.rb
+- lib/queue.rb
+- lib/ruby-qmail.rb
+- spec/ruby-qmail_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/afair/ruby-qmail
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby interfaces for Qmail
+test_files: 
+- spec/ruby-qmail_spec.rb
+- spec/spec_helper.rb